1 /*
2 * Copyright (C) 2018 Alberto Irurueta Carro (alberto@irurueta.com)
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 package com.irurueta.navigation.indoor.radiosource;
17
18 import com.irurueta.geometry.Point2D;
19 import com.irurueta.navigation.LockedException;
20 import com.irurueta.navigation.NavigationException;
21 import com.irurueta.navigation.indoor.Beacon;
22 import com.irurueta.navigation.indoor.BeaconWithPowerAndLocated2D;
23 import com.irurueta.navigation.indoor.RadioSource;
24 import com.irurueta.navigation.indoor.RadioSourceWithPowerAndLocated;
25 import com.irurueta.navigation.indoor.RangingAndRssiReadingLocated;
26 import com.irurueta.navigation.indoor.WifiAccessPoint;
27 import com.irurueta.navigation.indoor.WifiAccessPointWithPowerAndLocated2D;
28 import com.irurueta.numerical.robust.RobustEstimatorMethod;
29
30 import java.util.ArrayList;
31 import java.util.List;
32
33 /**
34 * This is an abstract class to robustly estimate 2D position, transmitted power and path-loss
35 * exponent of a radio source (e.g. Wi-Fi access point or bluetooth beacon), by discarding
36 * outliers and assuming that the ranging data is available to obtain position with
37 * greater accuracy and that the radio source emits isotropically following the
38 * expression below:
39 * Pr = Pt*Gt*Gr*lambda^2 / (4*pi*d)^2,
40 * where Pr is the received power (expressed in mW),
41 * Gt is the Gain of the transmission antenna
42 * Gr is the Gain of the receiver antenna
43 * d is the distance between emitter and receiver
44 * and lambda is the wavelength and is equal to: lambda = c / f,
45 * where c is the speed of light
46 * and f is the carrier frequency of the radio signal.
47 * Because usually information about the antenna of the radio source cannot be
48 * retrieved (because many measurements are made on unknown devices where
49 * physical access is not possible), this implementation will estimate the
50 * equivalent transmitted power as: Pte = Pt * Gt * Gr.
51 * If Readings contain RSSI standard deviations, those values will be used,
52 * otherwise it will be assumed an RSSI standard deviation of 1 dB.
53 * <p>
54 * Although RobustRssiRadioSourceEstimator can estimate the same parameters of a radio
55 * source, when ranging measures are available along with RSSI measurements,
56 * implementations of this class should be preferred instead as they can provide
57 * greater accuracy.
58 *
59 * @param <S> a {@link RadioSource} type.
60 */
61 public abstract class RobustRangingAndRssiRadioSourceEstimator2D<S extends RadioSource> extends
62 RobustRangingAndRssiRadioSourceEstimator<S, Point2D> {
63
64 /**
65 * Radio source estimator used internally.
66 */
67 protected final RangingAndRssiRadioSourceEstimator2D<S> innerEstimator = new RangingAndRssiRadioSourceEstimator2D<>();
68
69 /**
70 * Subset of readings used by inner estimator.
71 */
72 private final List<RangingAndRssiReadingLocated<S, Point2D>> innerReadings = new ArrayList<>();
73
74 /**
75 * Constructor.
76 */
77 protected RobustRangingAndRssiRadioSourceEstimator2D() {
78 super();
79 preliminarySubsetSize = getMinReadings();
80 }
81
82 /**
83 * Constructor.
84 * Sets signal readings belonging to the same radio source.
85 *
86 * @param readings signal readings belonging to the same radio source.
87 * @throws IllegalArgumentException if readings are not valid.
88 */
89 protected RobustRangingAndRssiRadioSourceEstimator2D(
90 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings) {
91 super(readings);
92 preliminarySubsetSize = getMinReadings();
93 }
94
95 /**
96 * Constructor.
97 *
98 * @param listener listener in charge of attending events raised by this instance.
99 */
100 protected RobustRangingAndRssiRadioSourceEstimator2D(
101 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
102 super(listener);
103 preliminarySubsetSize = getMinReadings();
104 }
105
106 /**
107 * Constructor.
108 * Sets signal readings belonging to the same radio source.
109 *
110 * @param readings signal readings belonging to the same radio source.
111 * @param listener listener in charge of attending events raised by this instance.
112 * @throws IllegalArgumentException if readings are not valid.
113 */
114 protected RobustRangingAndRssiRadioSourceEstimator2D(
115 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
116 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
117 super(readings, listener);
118 preliminarySubsetSize = getMinReadings();
119 }
120
121 /**
122 * Constructor.
123 * Sets signal readings belonging to the same radio source.
124 *
125 * @param readings signal readings belonging to the same radio source.
126 * @param initialPosition initial position to start the estimation of radio
127 * source position.
128 * @throws IllegalArgumentException if readings are not valid.
129 */
130 protected RobustRangingAndRssiRadioSourceEstimator2D(
131 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition) {
132 super(readings, initialPosition);
133 preliminarySubsetSize = getMinReadings();
134 }
135
136 /**
137 * Constructor.
138 *
139 * @param initialPosition initial position to start the estimation of radio
140 * source position.
141 */
142 protected RobustRangingAndRssiRadioSourceEstimator2D(final Point2D initialPosition) {
143 super(initialPosition);
144 preliminarySubsetSize = getMinReadings();
145 }
146
147 /**
148 * Constructor.
149 *
150 * @param initialPosition initial position to start the estimation of radio
151 * source position.
152 * @param listener listener in charge of attending events raised by this instance.
153 */
154 protected RobustRangingAndRssiRadioSourceEstimator2D(
155 final Point2D initialPosition,
156 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
157 super(initialPosition, listener);
158 preliminarySubsetSize = getMinReadings();
159 }
160
161 /**
162 * Constructor.
163 * Sets signal readings belonging to the same radio source.
164 *
165 * @param readings signal readings belonging to the same radio source.
166 * @param initialPosition initial position to start the estimation of radio
167 * source position.
168 * @param listener listener in charge of attending events raised by this instance.
169 * @throws IllegalArgumentException if readings are not valid.
170 */
171 protected RobustRangingAndRssiRadioSourceEstimator2D(
172 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
173 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
174 super(readings, initialPosition, listener);
175 preliminarySubsetSize = getMinReadings();
176 }
177
178 /**
179 * Constructor.
180 *
181 * @param initialTransmittedPowerdBm initial transmitted power to start the
182 * estimation of radio source transmitted power
183 * (expressed in dBm's)
184 */
185 protected RobustRangingAndRssiRadioSourceEstimator2D(final Double initialTransmittedPowerdBm) {
186 super(initialTransmittedPowerdBm);
187 preliminarySubsetSize = getMinReadings();
188 }
189
190 /**
191 * Constructor.
192 * Sets signal readings belonging to the same radio source.
193 *
194 * @param readings Wi-Fi signal readings belonging to the same radio source.
195 * @param initialTransmittedPowerdBm initial transmitted power to start the
196 * estimation of radio source transmitted power
197 * (expressed in dBm's)
198 * @throws IllegalArgumentException if readings are not valid.
199 */
200 protected RobustRangingAndRssiRadioSourceEstimator2D(
201 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
202 final Double initialTransmittedPowerdBm) {
203 super(readings, initialTransmittedPowerdBm);
204 preliminarySubsetSize = getMinReadings();
205 }
206
207 /**
208 * Constructor.
209 *
210 * @param initialTransmittedPowerdBm initial transmitted power to start the
211 * estimation of radio source transmitted power
212 * (expressed in dBm's)
213 * @param listener listener in charge of attending events raised by this instance.
214 */
215 protected RobustRangingAndRssiRadioSourceEstimator2D(
216 final Double initialTransmittedPowerdBm,
217 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
218 super(initialTransmittedPowerdBm, listener);
219 preliminarySubsetSize = getMinReadings();
220 }
221
222 /**
223 * Constructor.
224 * Sets signal readings belonging to the same radio source.
225 *
226 * @param readings Wi-Fi signal readings belonging to the radio source point.
227 * @param initialTransmittedPowerdBm initial transmitted power to start the
228 * estimation of radio source transmitted power
229 * (expressed in dBm's)
230 * @param listener listener in charge of attending events raised by this instance.
231 * @throws IllegalArgumentException if readings are not valid.
232 */
233 protected RobustRangingAndRssiRadioSourceEstimator2D(
234 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
235 final Double initialTransmittedPowerdBm,
236 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
237 super(readings, initialTransmittedPowerdBm, listener);
238 preliminarySubsetSize = getMinReadings();
239 }
240
241 /**
242 * Constructor.
243 * Sets signal readings belonging to the same radio source.
244 *
245 * @param readings signal readings belonging to the same radio source.
246 * @param initialPosition initial position to start the estimation of radio
247 * source position.
248 * @param initialTransmittedPowerdBm initial transmitted power to start the
249 * estimation of radio source transmitted power
250 * (expressed in dBm's).
251 * @throws IllegalArgumentException if readings are not valid.
252 */
253 protected RobustRangingAndRssiRadioSourceEstimator2D(
254 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
255 final Double initialTransmittedPowerdBm) {
256 super(readings, initialPosition, initialTransmittedPowerdBm);
257 preliminarySubsetSize = getMinReadings();
258 }
259
260 /**
261 * Constructor.
262 *
263 * @param initialPosition initial position to start the estimation of radio
264 * source position.
265 * @param initialTransmittedPowerdBm initial transmitted power to start the
266 * estimation of radio source transmitted power
267 * (expressed in dBm's).
268 */
269 protected RobustRangingAndRssiRadioSourceEstimator2D(
270 final Point2D initialPosition, final Double initialTransmittedPowerdBm) {
271 super(initialPosition, initialTransmittedPowerdBm);
272 preliminarySubsetSize = getMinReadings();
273 }
274
275 /**
276 * Constructor.
277 *
278 * @param initialPosition initial position to start the estimation of radio
279 * source position.
280 * @param initialTransmittedPowerdBm initial transmitted power to start the
281 * estimation of radio source transmitted power
282 * (expressed in dBm's).
283 * @param listener listener in charge of attending events raised by this instance.
284 */
285 protected RobustRangingAndRssiRadioSourceEstimator2D(
286 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
287 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
288 super(initialPosition, initialTransmittedPowerdBm, listener);
289 preliminarySubsetSize = getMinReadings();
290 }
291
292 /**
293 * Constructor.
294 * Sets signal readings belonging to the same radio source.
295 *
296 * @param readings signal readings belonging to the same radio source.
297 * @param initialPosition initial position to start the estimation of radio
298 * source position.
299 * @param initialTransmittedPowerdBm initial transmitted power to start the
300 * estimation of radio source transmitted power
301 * (expressed in dBm's).
302 * @param listener listener in charge of attending events raised by this instance.
303 * @throws IllegalArgumentException if readings are not valid.
304 */
305 protected RobustRangingAndRssiRadioSourceEstimator2D(
306 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
307 final Double initialTransmittedPowerdBm,
308 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
309 super(readings, initialPosition, initialTransmittedPowerdBm, listener);
310 preliminarySubsetSize = getMinReadings();
311 }
312
313 /**
314 * Constructor.
315 * Sets signal readings belonging to the same radio source.
316 *
317 * @param readings signal readings belonging to the same radio source.
318 * @param initialPosition initial position to start the estimation of radio
319 * source position.
320 * @param initialTransmittedPowerdBm initial transmitted power to start the
321 * estimation of radio source transmitted power
322 * (expressed in dBm's).
323 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
324 * @throws IllegalArgumentException if readings are not valid.
325 */
326 protected RobustRangingAndRssiRadioSourceEstimator2D(
327 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
328 final Double initialTransmittedPowerdBm, final double initialPathLossExponent) {
329 super(readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent);
330 preliminarySubsetSize = getMinReadings();
331 }
332
333 /**
334 * Constructor.
335 *
336 * @param initialPosition initial position to start the estimation of radio
337 * source position.
338 * @param initialTransmittedPowerdBm initial transmitted power to start the
339 * estimation of radio source transmitted power
340 * (expressed in dBm's).
341 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
342 */
343 protected RobustRangingAndRssiRadioSourceEstimator2D(
344 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
345 final double initialPathLossExponent) {
346 super(initialPosition, initialTransmittedPowerdBm, initialPathLossExponent);
347 preliminarySubsetSize = getMinReadings();
348 }
349
350 /**
351 * Constructor.
352 *
353 * @param initialPosition initial position to start the estimation of radio
354 * source position.
355 * @param initialTransmittedPowerdBm initial transmitted power to start the
356 * estimation of radio source transmitted power
357 * (expressed in dBm's).
358 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
359 * @param listener listener in charge of attending events raised by this instance.
360 */
361 protected RobustRangingAndRssiRadioSourceEstimator2D(
362 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
363 final double initialPathLossExponent,
364 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
365 super(initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener);
366 preliminarySubsetSize = getMinReadings();
367 }
368
369 /**
370 * Constructor.
371 * Sets signal readings belonging to the same radio source.
372 *
373 * @param readings signal readings belonging to the same radio source.
374 * @param initialPosition initial position to start the estimation of radio
375 * source position.
376 * @param initialTransmittedPowerdBm initial transmitted power to start the
377 * estimation of radio source transmitted power
378 * (expressed in dBm's).
379 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
380 * @param listener listener in charge of attending events raised by this instance.
381 * @throws IllegalArgumentException if readings are not valid.
382 */
383 protected RobustRangingAndRssiRadioSourceEstimator2D(
384 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
385 final Double initialTransmittedPowerdBm, final double initialPathLossExponent,
386 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
387 super(readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener);
388 preliminarySubsetSize = getMinReadings();
389 }
390
391 /**
392 * Creates a robust 2D position radio source estimator.
393 *
394 * @param method robust estimator method.
395 * @param <S> a {@link RadioSource} type.
396 * @return a new robust 2D position radio source estimator.
397 */
398 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
399 final RobustEstimatorMethod method) {
400 return switch (method) {
401 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>();
402 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>();
403 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>();
404 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>();
405 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>();
406 };
407 }
408
409 /**
410 * Creates a robust 2D position radio source estimator.
411 *
412 * @param readings signal readings belonging to the same radio source.
413 * @param method robust estimator method.
414 * @param <S> a {@link RadioSource} type.
415 * @return a new robust 2D position radio source estimator.
416 * @throws IllegalArgumentException if readings are not valid.
417 */
418 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
419 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
420 final RobustEstimatorMethod method) {
421 return switch (method) {
422 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
423 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
424 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
425 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
426 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
427 };
428 }
429
430 /**
431 * Creates a robust 2D position radio source estimator.
432 *
433 * @param listener listener in charge of attending events raised by this instance.
434 * @param method robust estimator method.
435 * @param <S> a {@link RadioSource} type.
436 * @return a new robust 2D position radio source estimator.
437 */
438 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
439 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
440 final RobustEstimatorMethod method) {
441 return switch (method) {
442 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
443 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
444 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
445 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
446 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
447 };
448 }
449
450 /**
451 * Creates a robust 2D position radio source estimator.
452 *
453 * @param readings signal readings belonging to the same radio source.
454 * @param listener listener in charge of attending events raised by this instance.
455 * @param method robust estimator method.
456 * @param <S> a {@link RadioSource} type.
457 * @return a new robust 2D position radio source estimator.
458 * @throws IllegalArgumentException if readings are not valid.
459 */
460 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
461 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
462 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
463 final RobustEstimatorMethod method) {
464 return switch (method) {
465 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
466 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
467 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
468 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
469 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
470 };
471 }
472
473 /**
474 * Creates a robust 2D position radio source estimator.
475 *
476 * @param readings signal readings belonging to the same radio source.
477 * @param initialPosition initial position to start the estimation of radio
478 * source position.
479 * @param method robust estimator method.
480 * @param <S> a {@link RadioSource} type.
481 * @return a new robust 2D position radio source estimator.
482 * @throws IllegalArgumentException if readings are not valid.
483 */
484 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
485 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
486 final Point2D initialPosition, RobustEstimatorMethod method) {
487 return switch (method) {
488 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
489 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
490 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
491 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
492 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
493 };
494 }
495
496 /**
497 * Creates a robust 2D position radio source estimator.
498 *
499 * @param initialPosition initial position to start the estimation of radio
500 * source position.
501 * @param method robust estimator method.
502 * @param <S> a {@link RadioSource} type.
503 * @return a new robust 2D position radio source estimator.
504 */
505 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
506 final Point2D initialPosition, final RobustEstimatorMethod method) {
507 return switch (method) {
508 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
509 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
510 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
511 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
512 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
513 };
514 }
515
516 /**
517 * Creates a robust 2D position radio source estimator.
518 *
519 * @param initialPosition initial position to start the estimation of radio
520 * source position.
521 * @param listener listener in charge of attending events raised by this instance.
522 * @param method robust estimator method.
523 * @param <S> a {@link RadioSource} type.
524 * @return a new robust 2D position radio source estimator.
525 */
526 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
527 final Point2D initialPosition, final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
528 final RobustEstimatorMethod method) {
529 return switch (method) {
530 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
531 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
532 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
533 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
534 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
535 };
536 }
537
538 /**
539 * Creates a robust 2D position radio source estimator.
540 *
541 * @param readings signal readings belonging to the same radio source.
542 * @param initialPosition initial position to start the estimation of radio
543 * source position.
544 * @param listener listener in charge of attending events raised by this instance
545 * @param method robust estimator method.
546 * @param <S> a {@link RadioSource} type.
547 * @return a new robust 2D position radio source estimator.
548 * @throws IllegalArgumentException if readings are not valid.
549 */
550 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
551 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
552 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
553 final RobustEstimatorMethod method) {
554 return switch (method) {
555 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
556 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
557 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
558 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
559 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
560 };
561 }
562
563 /**
564 * Creates a robust 2D position radio source estimator.
565 *
566 * @param initialTransmittedPowerdBm initial transmitted power to start the
567 * estimation of radio source transmitted power
568 * (expressed in dBm's).
569 * @param method robust estimator method.
570 * @param <S> a {@link RadioSource} type.
571 * @return a new robust 2D position radio source estimator.
572 */
573 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
574 final Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
575 return switch (method) {
576 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
577 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
578 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
579 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
580 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
581 };
582 }
583
584 /**
585 * Creates a robust 2D position radio source estimator.
586 *
587 * @param readings signal readings belonging to the same radio source.
588 * @param initialTransmittedPowerdBm initial transmitted power to start the
589 * estimation of radio source transmitted power
590 * (expressed in dBm's).
591 * @param method robust estimator method.
592 * @param <S> a {@link RadioSource} type.
593 * @return a new robust 2D position radio source estimator.
594 * @throws IllegalArgumentException if readings are not valid.
595 */
596 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
597 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
598 final Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
599 return switch (method) {
600 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
601 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
602 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
603 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
604 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
605 };
606 }
607
608 /**
609 * Creates a robust 2D position radio source estimator.
610 *
611 * @param initialTransmittedPowerdBm initial transmitted power to start the
612 * estimation of radio source transmitted power
613 * (expressed in dBm's)
614 * @param listener listener in charge of attending events raised by this instance.
615 * @param method robust estimator method.
616 * @param <S> a {@link RadioSource} type.
617 * @return a new robust 2D position radio source estimator.
618 */
619 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
620 final Double initialTransmittedPowerdBm,
621 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
622 final RobustEstimatorMethod method) {
623 return switch (method) {
624 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
625 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
626 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
627 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
628 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
629 };
630 }
631
632 /**
633 * Creates a robust 2D position radio source estimator.
634 *
635 * @param readings signal readings belonging to the same radio source.
636 * @param initialTransmittedPowerdBm initial transmitted power to start the
637 * estimation of radio source transmitted power
638 * (expressed in dBm's)
639 * @param listener listener in charge of attending events raised by this instance.
640 * @param method robust estimator method.
641 * @param <S> a {@link RadioSource} type.
642 * @return a new robust 2D radio source power and position estimator.
643 * @throws IllegalArgumentException if readings are not valid.
644 */
645 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
646 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
647 final Double initialTransmittedPowerdBm,
648 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
649 final RobustEstimatorMethod method) {
650 return switch (method) {
651 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
652 listener);
653 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
654 listener);
655 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
656 listener);
657 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
658 listener);
659 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
660 listener);
661 };
662 }
663
664 /**
665 * Creates a robust 2D position radio source estimator.
666 *
667 * @param readings signal readings belonging to the same radio source.
668 * @param initialPosition initial position to start the estimation of radio
669 * source position.
670 * @param initialTransmittedPowerdBm initial transmitted power to start the
671 * estimation of radio source transmitted power
672 * (expressed in dBm's).
673 * @param method robust estimator method.
674 * @param <S> a {@link RadioSource} type.
675 * @return a new robust 2D radio source power and position estimator.
676 * @throws IllegalArgumentException if readings are not valid.
677 */
678 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
679 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
680 final Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
681 return switch (method) {
682 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
683 initialTransmittedPowerdBm);
684 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
685 initialTransmittedPowerdBm);
686 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
687 initialTransmittedPowerdBm);
688 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
689 initialTransmittedPowerdBm);
690 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
691 initialTransmittedPowerdBm);
692 };
693 }
694
695 /**
696 * Creates a robust 2D position radio source estimator.
697 *
698 * @param initialPosition initial position to start the estimation of radio
699 * source position.
700 * @param initialTransmittedPowerdBm initial transmitted power to start the
701 * estimation of radio source transmitted power
702 * (expressed in dBm's).
703 * @param method robust estimator method.
704 * @param <S> a {@link RadioSource} type.
705 * @return a new robust 2D position radio source estimator.
706 */
707 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
708 final Point2D initialPosition, Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
709 return switch (method) {
710 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
711 initialTransmittedPowerdBm);
712 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
713 initialTransmittedPowerdBm);
714 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
715 initialTransmittedPowerdBm);
716 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
717 initialTransmittedPowerdBm);
718 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
719 initialTransmittedPowerdBm);
720 };
721 }
722
723 /**
724 * Creates a robust 2D position radio source estimator.
725 *
726 * @param initialPosition initial position to start the estimation of radio
727 * source position.
728 * @param initialTransmittedPowerdBm initial transmitted power to start the
729 * estimation of radio source transmitted power
730 * (expressed in dBm's).
731 * @param listener listener in charge of attending events raised by this instance.
732 * @param method robust estimator method.
733 * @param <S> a {@link RadioSource} type.
734 * @return a new robust 2D position radio source estimator.
735 */
736 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
737 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
738 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
739 final RobustEstimatorMethod method) {
740 return switch (method) {
741 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
742 initialTransmittedPowerdBm, listener);
743 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
744 initialTransmittedPowerdBm, listener);
745 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
746 initialTransmittedPowerdBm, listener);
747 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
748 initialTransmittedPowerdBm, listener);
749 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
750 initialTransmittedPowerdBm, listener);
751 };
752 }
753
754 /**
755 * Creates a robust 2D position radio source estimator.
756 *
757 * @param readings signal readings belonging to the same radio source.
758 * @param initialPosition initial position to start the estimation of radio
759 * source position.
760 * @param initialTransmittedPowerdBm initial transmitted power to start the
761 * estimation of radio source transmitted power
762 * (expressed in dBm's).
763 * @param listener listener in charge of attending events raised by this instance.
764 * @param method robust estimator method.
765 * @param <S> a {@link RadioSource} type.
766 * @return a new robust 2D position radio source estimator.
767 * @throws IllegalArgumentException if readings are not valid.
768 */
769 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
770 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
771 final Double initialTransmittedPowerdBm,
772 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
773 final RobustEstimatorMethod method) {
774 return switch (method) {
775 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
776 initialTransmittedPowerdBm, listener);
777 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
778 initialTransmittedPowerdBm, listener);
779 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
780 initialTransmittedPowerdBm, listener);
781 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
782 initialTransmittedPowerdBm, listener);
783 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
784 initialTransmittedPowerdBm, listener);
785 };
786 }
787
788 /**
789 * Creates a robust 2D position radio source estimator.
790 *
791 * @param readings signal readings belonging to the same radio source.
792 * @param initialPosition initial position to start the estimation of radio
793 * source position.
794 * @param initialTransmittedPowerdBm initial transmitted power to start the
795 * estimation of radio source transmitted power
796 * (expressed in dBm's).
797 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
798 * @param method robust estimator method.
799 * @param <S> a {@link RadioSource} type.
800 * @return a new robust 2D position radio source estimator.
801 * @throws IllegalArgumentException if readings are not valid.
802 */
803 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
804 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
805 Double initialTransmittedPowerdBm, final double initialPathLossExponent,
806 final RobustEstimatorMethod method) {
807 return switch (method) {
808 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
809 initialTransmittedPowerdBm, initialPathLossExponent);
810 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
811 initialTransmittedPowerdBm, initialPathLossExponent);
812 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
813 initialTransmittedPowerdBm, initialPathLossExponent);
814 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
815 initialTransmittedPowerdBm, initialPathLossExponent);
816 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
817 initialTransmittedPowerdBm, initialPathLossExponent);
818 };
819 }
820
821 /**
822 * Creates a robust 2D position radio source estimator.
823 *
824 * @param initialPosition initial position to start the estimation of radio
825 * source position.
826 * @param initialTransmittedPowerdBm initial transmitted power to start the
827 * estimation of radio source transmitted power
828 * (expressed in dBm's).
829 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
830 * @param method robust estimator method.
831 * @param <S> a {@link RadioSource} type.
832 * @return a new robust 2D position radio source estimator.
833 */
834 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
835 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
836 final double initialPathLossExponent, final RobustEstimatorMethod method) {
837 return switch (method) {
838 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
839 initialTransmittedPowerdBm, initialPathLossExponent);
840 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
841 initialTransmittedPowerdBm, initialPathLossExponent);
842 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
843 initialTransmittedPowerdBm, initialPathLossExponent);
844 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
845 initialTransmittedPowerdBm, initialPathLossExponent);
846 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
847 initialTransmittedPowerdBm, initialPathLossExponent);
848 };
849 }
850
851 /**
852 * Creates a robust 2D position radio source estimator.
853 *
854 * @param initialPosition initial position to start the estimation of radio
855 * source position.
856 * @param initialTransmittedPowerdBm initial transmitted power to start the
857 * estimation of radio source transmitted power
858 * (expressed in dBm's).
859 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
860 * @param listener listener in charge of attending events raised by this instance.
861 * @param method robust estimator method.
862 * @param <S> a {@link RadioSource} type.
863 * @return a new robust 2D position radio source estimator.
864 */
865 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
866 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
867 final double initialPathLossExponent,
868 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
869 final RobustEstimatorMethod method) {
870 return switch (method) {
871 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
872 initialTransmittedPowerdBm, initialPathLossExponent, listener);
873 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
874 initialTransmittedPowerdBm, initialPathLossExponent, listener);
875 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
876 initialTransmittedPowerdBm, initialPathLossExponent, listener);
877 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
878 initialTransmittedPowerdBm, initialPathLossExponent, listener);
879 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
880 initialTransmittedPowerdBm, initialPathLossExponent, listener);
881 };
882 }
883
884 /**
885 * Creates a robust 2D position radio source estimator.
886 *
887 * @param readings signal readings belonging to the same radio source.
888 * @param initialPosition initial position to start the estimation of radio
889 * source position.
890 * @param initialTransmittedPowerdBm initial transmitted power to start the
891 * estimation of radio source transmitted power
892 * (expressed in dBm's).
893 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
894 * @param listener listener in charge of attending events raised by this instance.
895 * @param method robust estimator method.
896 * @param <S> a {@link RadioSource} type.
897 * @return a new robust 2D position radio source estimator.
898 * @throws IllegalArgumentException if readings are not valid.
899 */
900 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
901 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
902 final Double initialTransmittedPowerdBm, final double initialPathLossExponent,
903 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
904 final RobustEstimatorMethod method) {
905 return switch (method) {
906 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
907 initialTransmittedPowerdBm, initialPathLossExponent, listener);
908 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
909 initialTransmittedPowerdBm, initialPathLossExponent, listener);
910 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
911 initialTransmittedPowerdBm, initialPathLossExponent, listener);
912 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
913 initialTransmittedPowerdBm, initialPathLossExponent, listener);
914 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
915 initialTransmittedPowerdBm, initialPathLossExponent, listener);
916 };
917 }
918
919 /**
920 * Creates a robust 2D position radio source estimator.
921 *
922 * @param qualityScores quality scores corresponding to each provided
923 * sample. The larger the score value the better
924 * the quality of the sample.
925 * @param method robust estimator method.
926 * @param <S> a {@link RadioSource} type.
927 * @return a new robust 2D position radio source estimator.
928 */
929 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
930 final double[] qualityScores, final RobustEstimatorMethod method) {
931 return switch (method) {
932 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>();
933 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>();
934 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>();
935 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores);
936 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores);
937 };
938 }
939
940 /**
941 * Creates a robust 2D position radio source estimator.
942 *
943 * @param qualityScores quality scores corresponding to each provided
944 * sample. The larger the score value the better
945 * the quality of the sample.
946 * @param readings signal readings belonging to the same radio source.
947 * @param method robust estimator method.
948 * @param <S> a {@link RadioSource} type.
949 * @return a new robust 2D position radio source estimator.
950 * @throws IllegalArgumentException if readings are not valid.
951 */
952 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
953 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
954 final RobustEstimatorMethod method) {
955 return switch (method) {
956 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
957 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
958 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings);
959 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings);
960 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings);
961 };
962 }
963
964 /**
965 * Creates a robust 2D position radio source estimator.
966 *
967 * @param qualityScores quality scores corresponding to each provided
968 * sample. The larger the score value the better
969 * the quality of the sample.
970 * @param listener listener in charge of attending events raised by this instance.
971 * @param method robust estimator method.
972 * @param <S> a {@link RadioSource} type.
973 * @return a new robust 2D position radio source estimator.
974 */
975 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
976 final double[] qualityScores, final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
977 final RobustEstimatorMethod method) {
978 return switch (method) {
979 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
980 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
981 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(listener);
982 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, listener);
983 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, listener);
984 };
985 }
986
987 /**
988 * Creates a robust 2D position radio source estimator.
989 *
990 * @param qualityScores quality scores corresponding to each provided
991 * sample. The larger the score value the better
992 * the quality of the sample.
993 * @param readings signal readings belonging to the same radio source.
994 * @param listener listener in charge of attending events raised by this instance.
995 * @param method robust estimator method.
996 * @param <S> a {@link RadioSource} type.
997 * @return a new robust 2D position radio source estimator.
998 * @throws IllegalArgumentException if readings are not valid.
999 */
1000 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1001 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1002 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1003 final RobustEstimatorMethod method) {
1004 return switch (method) {
1005 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
1006 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
1007 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, listener);
1008 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, listener);
1009 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, listener);
1010 };
1011 }
1012
1013 /**
1014 * Creates a robust 2D position radio source estimator.
1015 *
1016 * @param qualityScores quality scores corresponding to each provided
1017 * sample. The larger the score value the better
1018 * the quality of the sample.
1019 * @param readings signal readings belonging to the same radio source.
1020 * @param initialPosition initial position to start the estimation of radio
1021 * source position.
1022 * @param method robust estimator method.
1023 * @param <S> a {@link RadioSource} type.
1024 * @return a new robust 2D position radio source estimator.
1025 * @throws IllegalArgumentException if readings are not valid.
1026 */
1027 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1028 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1029 final Point2D initialPosition, final RobustEstimatorMethod method) {
1030 return switch (method) {
1031 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
1032 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
1033 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition);
1034 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1035 initialPosition);
1036 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1037 initialPosition);
1038 };
1039 }
1040
1041 /**
1042 * Creates a robust 2D position radio source estimator.
1043 *
1044 * @param qualityScores quality scores corresponding to each provided
1045 * sample. The larger the score value the better
1046 * the quality of the sample.
1047 * @param initialPosition initial position to start the estimation of radio
1048 * source position.
1049 * @param method robust estimator method.
1050 * @param <S> a {@link RadioSource} type.
1051 * @return a new robust 2D position radio source estimator.
1052 */
1053 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1054 final double[] qualityScores, final Point2D initialPosition, final RobustEstimatorMethod method) {
1055 return switch (method) {
1056 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
1057 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
1058 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition);
1059 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition);
1060 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition);
1061 };
1062 }
1063
1064 /**
1065 * Creates a robust 2D position radio source estimator.
1066 *
1067 * @param qualityScores quality scores corresponding to each provided
1068 * sample. The larger the score value the better
1069 * the quality of the sample.
1070 * @param initialPosition initial position to start the estimation of radio
1071 * source position.
1072 * @param listener listener in charge of attending events raised by this instance.
1073 * @param method robust estimator method.
1074 * @param <S> a {@link RadioSource} type.
1075 * @return a new robust 2D position radio source estimator.
1076 */
1077 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1078 final double[] qualityScores, final Point2D initialPosition,
1079 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1080 final RobustEstimatorMethod method) {
1081 return switch (method) {
1082 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
1083 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
1084 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition, listener);
1085 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1086 listener);
1087 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1088 listener);
1089 };
1090 }
1091
1092 /**
1093 * Creates a robust 2D position radio source estimator.
1094 *
1095 * @param qualityScores quality scores corresponding to each provided
1096 * sample. The larger the score value the better
1097 * the quality of the sample.
1098 * @param readings signal readings belonging to the same radio source.
1099 * @param initialPosition initial position to start the estimation of radio
1100 * source position.
1101 * @param listener listener in charge of attending events raised by this instance
1102 * @param method robust estimator method.
1103 * @param <S> a {@link RadioSource} type.
1104 * @return a new robust 2D position radio source estimator.
1105 * @throws IllegalArgumentException if readings are not valid.
1106 */
1107 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1108 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1109 final Point2D initialPosition, final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1110 final RobustEstimatorMethod method) {
1111 return switch (method) {
1112 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
1113 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
1114 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition, listener);
1115 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1116 initialPosition, listener);
1117 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, initialPosition,
1118 listener);
1119 };
1120 }
1121
1122 /**
1123 * Creates a robust 2D position radio source estimator.
1124 *
1125 * @param qualityScores quality scores corresponding to each provided
1126 * sample. The larger the score value the better
1127 * the quality of the sample.
1128 * @param initialTransmittedPowerdBm initial transmitted power to start the
1129 * estimation of access point transmitted power
1130 * (expressed in dBm's).
1131 * @param method robust estimator method.
1132 * @param <S> a {@link RadioSource} type.
1133 * @return a new robust 2D position radio source estimator.
1134 */
1135 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1136 final double[] qualityScores, final Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
1137 return switch (method) {
1138 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
1139 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
1140 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm);
1141 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores,
1142 initialTransmittedPowerdBm);
1143 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores,
1144 initialTransmittedPowerdBm);
1145 };
1146 }
1147
1148 /**
1149 * Creates a robust 2D position radio source estimator.
1150 *
1151 * @param qualityScores quality scores corresponding to each provided
1152 * sample. The larger the score value the better
1153 * the quality of the sample.
1154 * @param readings signal readings belonging to the same radio source.
1155 * @param initialTransmittedPowerdBm initial transmitted power to start the
1156 * estimation of radio source transmitted power
1157 * (expressed in dBm's).
1158 * @param method robust estimator method.
1159 * @param <S> a {@link RadioSource} type.
1160 * @return a new robust 2D position radio source estimator.
1161 * @throws IllegalArgumentException if readings are not valid.
1162 */
1163 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1164 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1165 final Double initialTransmittedPowerdBm, final RobustEstimatorMethod method) {
1166 return switch (method) {
1167 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
1168 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
1169 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm);
1170 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1171 initialTransmittedPowerdBm);
1172 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1173 initialTransmittedPowerdBm);
1174 };
1175 }
1176
1177 /**
1178 * Creates a robust 2D position radio source estimator.
1179 *
1180 * @param qualityScores quality scores corresponding to each provided
1181 * sample. The larger the score value the better
1182 * the quality of the sample.
1183 * @param initialTransmittedPowerdBm initial transmitted power to start the
1184 * estimation of radio source transmitted power
1185 * (expressed in dBm's)
1186 * @param listener listener in charge of attending events raised by this instance.
1187 * @param method robust estimator method.
1188 * @param <S> a {@link RadioSource} type.
1189 * @return a new robust 2D position radio source estimator.
1190 */
1191 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1192 final double[] qualityScores, final Double initialTransmittedPowerdBm,
1193 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1194 final RobustEstimatorMethod method) {
1195 return switch (method) {
1196 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
1197 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
1198 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialTransmittedPowerdBm, listener);
1199 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores,
1200 initialTransmittedPowerdBm, listener);
1201 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores,
1202 initialTransmittedPowerdBm, listener);
1203 };
1204 }
1205
1206 /**
1207 * Creates a robust 2D position radio source estimator.
1208 *
1209 * @param qualityScores quality scores corresponding to each provided
1210 * sample. The larger the score value the better
1211 * the quality of the sample.
1212 * @param readings signal readings belonging to the same radio source.
1213 * @param initialTransmittedPowerdBm initial transmitted power to start the
1214 * estimation of radio source transmitted power
1215 * (expressed in dBm's)
1216 * @param listener listener in charge of attending events raised by this instance.
1217 * @param method robust estimator method.
1218 * @param <S> a {@link RadioSource} type.
1219 * @return a new robust 2D position radio source estimator.
1220 * @throws IllegalArgumentException if readings are not valid.
1221 */
1222 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1223 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1224 final Double initialTransmittedPowerdBm,
1225 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1226 final RobustEstimatorMethod method) {
1227 return switch (method) {
1228 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
1229 listener);
1230 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
1231 listener);
1232 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialTransmittedPowerdBm,
1233 listener);
1234 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1235 initialTransmittedPowerdBm, listener);
1236 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1237 initialTransmittedPowerdBm, listener);
1238 };
1239 }
1240
1241 /**
1242 * Creates a robust 2D position radio source estimator.
1243 *
1244 * @param qualityScores quality scores corresponding to each provided
1245 * sample. The larger the score value the better
1246 * the quality of the sample.
1247 * @param readings signal readings belonging to the same radio source.
1248 * @param initialPosition initial position to start the estimation of radio
1249 * source position.
1250 * @param initialTransmittedPowerdBm initial transmitted power to start the
1251 * estimation of radio source transmitted power
1252 * (expressed in dBm's).
1253 * @param method robust estimator method.
1254 * @param <S> a {@link RadioSource} type.
1255 * @return a new robust 2D position radio source estimator.
1256 * @throws IllegalArgumentException if readings are not valid.
1257 */
1258 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1259 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1260 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1261 final RobustEstimatorMethod method) {
1262 return switch (method) {
1263 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1264 initialTransmittedPowerdBm);
1265 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1266 initialTransmittedPowerdBm);
1267 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1268 initialTransmittedPowerdBm);
1269 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1270 initialPosition, initialTransmittedPowerdBm);
1271 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, initialPosition,
1272 initialTransmittedPowerdBm);
1273 };
1274 }
1275
1276 /**
1277 * Creates a robust 2D position radio source estimator.
1278 *
1279 * @param qualityScores quality scores corresponding to each provided
1280 * sample. The larger the score value the better
1281 * the quality of the sample.
1282 * @param initialPosition initial position to start the estimation of radio
1283 * source position.
1284 * @param initialTransmittedPowerdBm initial transmitted power to start the
1285 * estimation of radio source transmitted power
1286 * (expressed in dBm's).
1287 * @param method robust estimator method.
1288 * @param <S> a {@link RadioSource} type.
1289 * @return a new robust 2D position radio source estimator.
1290 */
1291 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1292 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1293 final RobustEstimatorMethod method) {
1294 return switch (method) {
1295 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1296 initialTransmittedPowerdBm);
1297 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1298 initialTransmittedPowerdBm);
1299 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1300 initialTransmittedPowerdBm);
1301 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1302 initialTransmittedPowerdBm);
1303 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1304 initialTransmittedPowerdBm);
1305 };
1306 }
1307
1308 /**
1309 * Creates a robust 2D position radio source estimator.
1310 *
1311 * @param qualityScores quality scores corresponding to each provided
1312 * sample. The larger the score value the better
1313 * the quality of the sample.
1314 * @param initialPosition initial position to start the estimation of radio
1315 * source position.
1316 * @param initialTransmittedPowerdBm initial transmitted power to start the
1317 * estimation of radio source transmitted power
1318 * (expressed in dBm's).
1319 * @param listener listener in charge of attending events raised by this instance.
1320 * @param method robust estimator method.
1321 * @param <S> a {@link RadioSource} type.
1322 * @return a new robust 2D position radio source estimator.
1323 */
1324 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1325 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1326 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1327 final RobustEstimatorMethod method) {
1328 return switch (method) {
1329 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1330 initialTransmittedPowerdBm, listener);
1331 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1332 initialTransmittedPowerdBm, listener);
1333 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1334 initialTransmittedPowerdBm, listener);
1335 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1336 initialTransmittedPowerdBm, listener);
1337 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1338 initialTransmittedPowerdBm, listener);
1339 };
1340 }
1341
1342 /**
1343 * Creates a robust 2D position radio source estimator.
1344 *
1345 * @param qualityScores quality scores corresponding to each provided
1346 * sample. The larger the score value the better
1347 * the quality of the sample.
1348 * @param readings signal readings belonging to the same radio source.
1349 * @param initialPosition initial position to start the estimation of radio
1350 * source position.
1351 * @param initialTransmittedPowerdBm initial transmitted power to start the
1352 * estimation of radio source transmitted power
1353 * (expressed in dBm's).
1354 * @param listener listener in charge of attending events raised by this instance.
1355 * @param method robust estimator method.
1356 * @param <S> a {@link RadioSource} type.
1357 * @return a new robust 2D position radio source estimator.
1358 * @throws IllegalArgumentException if readings are not valid.
1359 */
1360 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1361 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1362 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1363 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1364 final RobustEstimatorMethod method) {
1365 return switch (method) {
1366 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1367 initialTransmittedPowerdBm, listener);
1368 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1369 initialTransmittedPowerdBm, listener);
1370 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1371 initialTransmittedPowerdBm, listener);
1372 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1373 initialPosition, initialTransmittedPowerdBm, listener);
1374 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, initialPosition,
1375 initialTransmittedPowerdBm, listener);
1376 };
1377 }
1378
1379 /**
1380 * Creates a robust 2D position radio source estimator.
1381 *
1382 * @param qualityScores quality scores corresponding to each provided
1383 * sample. The larger the score value the better
1384 * the quality of the sample.
1385 * @param readings signal readings belonging to the same radio source.
1386 * @param initialPosition initial position to start the estimation of radio
1387 * source position.
1388 * @param initialTransmittedPowerdBm initial transmitted power to start the
1389 * estimation of radio source transmitted power
1390 * (expressed in dBm's).
1391 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1392 * @param method robust estimator method.
1393 * @param <S> a {@link RadioSource} type.
1394 * @return a new robust 2D position radio source estimator.
1395 * @throws IllegalArgumentException if readings are not valid.
1396 */
1397 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1398 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1399 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1400 final double initialPathLossExponent, final RobustEstimatorMethod method) {
1401 return switch (method) {
1402 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1403 initialTransmittedPowerdBm, initialPathLossExponent);
1404 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1405 initialTransmittedPowerdBm, initialPathLossExponent);
1406 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1407 initialTransmittedPowerdBm, initialPathLossExponent);
1408 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1409 initialPosition, initialTransmittedPowerdBm, initialPathLossExponent);
1410 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, initialPosition,
1411 initialTransmittedPowerdBm, initialPathLossExponent);
1412 };
1413 }
1414
1415 /**
1416 * Creates a robust 2D position radio source estimator.
1417 *
1418 * @param qualityScores quality scores corresponding to each provided
1419 * sample. The larger the score value the better
1420 * the quality of the sample.
1421 * @param initialPosition initial position to start the estimation of radio
1422 * source position.
1423 * @param initialTransmittedPowerdBm initial transmitted power to start the
1424 * estimation of radio source transmitted power
1425 * (expressed in dBm's).
1426 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1427 * @param method robust estimator method.
1428 * @param <S> a {@link RadioSource} type.
1429 * @return a new robust 2D position radio source estimator.
1430 */
1431 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1432 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1433 final double initialPathLossExponent, final RobustEstimatorMethod method) {
1434 return switch (method) {
1435 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1436 initialTransmittedPowerdBm, initialPathLossExponent);
1437 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1438 initialTransmittedPowerdBm, initialPathLossExponent);
1439 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1440 initialTransmittedPowerdBm, initialPathLossExponent);
1441 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1442 initialTransmittedPowerdBm, initialPathLossExponent);
1443 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1444 initialTransmittedPowerdBm, initialPathLossExponent);
1445 };
1446 }
1447
1448 /**
1449 * Creates a robust 2D position radio source estimator.
1450 *
1451 * @param qualityScores quality scores corresponding to each provided
1452 * sample. The larger the score value the better
1453 * the quality of the sample.
1454 * @param initialPosition initial position to start the estimation of radio
1455 * source position.
1456 * @param initialTransmittedPowerdBm initial transmitted power to start the
1457 * estimation of radio source transmitted power
1458 * (expressed in dBm's).
1459 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1460 * @param listener listener in charge of attending events raised by this instance.
1461 * @param method robust estimator method.
1462 * @param <S> a {@link RadioSource} type.
1463 * @return a new robust 2D position radio source estimator.
1464 */
1465 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1466 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1467 final double initialPathLossExponent,
1468 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1469 final RobustEstimatorMethod method) {
1470 return switch (method) {
1471 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1472 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1473 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1474 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1475 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(initialPosition,
1476 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1477 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1478 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1479 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, initialPosition,
1480 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1481 };
1482 }
1483
1484 /**
1485 * Creates a robust 2D position radio source estimator.
1486 *
1487 * @param qualityScores quality scores corresponding to each provided
1488 * sample. The larger the score value the better
1489 * the quality of the sample.
1490 * @param readings signal readings belonging to the same radio source.
1491 * @param initialPosition initial position to start the estimation of radio
1492 * source position.
1493 * @param initialTransmittedPowerdBm initial transmitted power to start the
1494 * estimation of radio source transmitted power
1495 * (expressed in dBm's).
1496 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1497 * @param listener listener in charge of attending events raised by this instance.
1498 * @param method robust estimator method.
1499 * @param <S> a {@link RadioSource} type.
1500 * @return a new robust 2D position radio source estimator.
1501 * @throws IllegalArgumentException if readings are not valid.
1502 */
1503 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1504 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1505 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1506 final double initialPathLossExponent,
1507 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener,
1508 final RobustEstimatorMethod method) {
1509 return switch (method) {
1510 case RANSAC -> new RANSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1511 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1512 case LMEDS -> new LMedSRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1513 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1514 case MSAC -> new MSACRobustRangingAndRssiRadioSourceEstimator2D<>(readings, initialPosition,
1515 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1516 case PROSAC -> new PROSACRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings,
1517 initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener);
1518 default -> new PROMedSRobustRangingAndRssiRadioSourceEstimator2D<>(qualityScores, readings, initialPosition,
1519 initialTransmittedPowerdBm, initialPathLossExponent, listener);
1520 };
1521 }
1522
1523 /**
1524 * Creates a robust 2D position radio source estimator using
1525 * default method.
1526 *
1527 * @param <S> a {@link RadioSource} type.
1528 * @return a new robust 2D position radio source estimator.
1529 */
1530 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create() {
1531 return create(DEFAULT_ROBUST_METHOD);
1532 }
1533
1534 /**
1535 * Creates a robust 2D position radio source estimator using
1536 * default method.
1537 *
1538 * @param readings signal readings belonging to the same radio source.
1539 * @param <S> a {@link RadioSource} type.
1540 * @return a new robust 2D position radio source estimator.
1541 * @throws IllegalArgumentException if readings are not valid.
1542 */
1543 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1544 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings) {
1545 return create(readings, DEFAULT_ROBUST_METHOD);
1546 }
1547
1548 /**
1549 * Creates a robust 2D position radio source estimator using
1550 * default method.
1551 *
1552 * @param listener listener in charge of attending events raised by this instance.
1553 * @param <S> a {@link RadioSource} type.
1554 * @return a new robust 2D position radio source estimator.
1555 */
1556 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1557 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1558 return create(listener, DEFAULT_ROBUST_METHOD);
1559 }
1560
1561 /**
1562 * Creates a robust 2D position radio source estimator using
1563 * default method.
1564 *
1565 * @param readings signal readings belonging to the same radio source.
1566 * @param listener listener in charge of attending events raised by this instance.
1567 * @param <S> a {@link RadioSource} type.
1568 * @return a new robust 2D position radio source estimator.
1569 * @throws IllegalArgumentException if readings are not valid.
1570 */
1571 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1572 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1573 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1574 return create(readings, listener, DEFAULT_ROBUST_METHOD);
1575 }
1576
1577 /**
1578 * Creates a robust 2D position radio source estimator using
1579 * default method.
1580 *
1581 * @param readings signal readings belonging to the same radio source.
1582 * @param initialPosition initial position to start the estimation of radio
1583 * source position.
1584 * @param <S> a {@link RadioSource} type.
1585 * @return a new robust 2D position radio source estimator.
1586 * @throws IllegalArgumentException if readings are not valid.
1587 */
1588 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1589 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition) {
1590 return create(readings, initialPosition, DEFAULT_ROBUST_METHOD);
1591 }
1592
1593 /**
1594 * Creates a robust 2D position radio source estimator using
1595 * default method.
1596 *
1597 * @param initialPosition initial position to start the estimation of radio
1598 * source position.
1599 * @param <S> a {@link RadioSource} type.
1600 * @return a new robust 2D position radio source estimator.
1601 */
1602 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1603 final Point2D initialPosition) {
1604 return create(initialPosition, DEFAULT_ROBUST_METHOD);
1605 }
1606
1607 /**
1608 * Creates a robust 2D position radio source estimator using
1609 * default method.
1610 *
1611 * @param initialPosition initial position to start the estimation of radio
1612 * source position.
1613 * @param listener listener in charge of attending events raised by this instance.
1614 * @param <S> a {@link RadioSource} type.
1615 * @return a new robust 2D position radio source estimator.
1616 */
1617 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1618 final Point2D initialPosition,
1619 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1620 return create(initialPosition, listener, DEFAULT_ROBUST_METHOD);
1621 }
1622
1623 /**
1624 * Creates a robust 2D position radio source estimator using
1625 * default method.
1626 *
1627 * @param readings signal readings belonging to the same radio source.
1628 * @param initialPosition initial position to start the estimation of radio
1629 * source position.
1630 * @param listener listener in charge of attending events raised by this instance
1631 * @param <S> a {@link RadioSource} type.
1632 * @return a new robust 2D position radio source estimator.
1633 * @throws IllegalArgumentException if readings are not valid.
1634 */
1635 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1636 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
1637 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1638 return create(readings, initialPosition, listener, DEFAULT_ROBUST_METHOD);
1639 }
1640
1641 /**
1642 * Creates a robust 2D position radio source estimator using
1643 * default method.
1644 *
1645 * @param initialTransmittedPowerdBm initial transmitted power to start the
1646 * estimation of radio source transmitted power
1647 * (expressed in dBm's).
1648 * @param <S> a {@link RadioSource} type.
1649 * @return a new robust 2D position radio source estimator.
1650 */
1651 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1652 final Double initialTransmittedPowerdBm) {
1653 return create(initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
1654 }
1655
1656 /**
1657 * Creates a robust 2D position radio source estimator using
1658 * default method.
1659 *
1660 * @param readings signal readings belonging to the same radio source.
1661 * @param initialTransmittedPowerdBm initial transmitted power to start the
1662 * estimation of radio source transmitted power
1663 * (expressed in dBm's).
1664 * @param <S> a {@link RadioSource} type.
1665 * @return a new robust 2D position radio source estimator.
1666 * @throws IllegalArgumentException if readings are not valid.
1667 */
1668 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1669 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1670 final Double initialTransmittedPowerdBm) {
1671 return create(readings, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
1672 }
1673
1674 /**
1675 * Creates a robust 2D position radio source estimator using
1676 * default method.
1677 *
1678 * @param initialTransmittedPowerdBm initial transmitted power to start the
1679 * estimation of radio source transmitted power
1680 * (expressed in dBm's)
1681 * @param listener listener in charge of attending events raised by this instance.
1682 * @param <S> a {@link RadioSource} type.
1683 * @return a new robust 2D position radio source estimator.
1684 */
1685 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1686 final Double initialTransmittedPowerdBm,
1687 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1688 return create(initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
1689 }
1690
1691 /**
1692 * Creates a robust 2D position radio source estimator using
1693 * default method.
1694 *
1695 * @param readings signal readings belonging to the same radio source.
1696 * @param initialTransmittedPowerdBm initial transmitted power to start the
1697 * estimation of radio source transmitted power
1698 * (expressed in dBm's)
1699 * @param listener listener in charge of attending events raised by this instance.
1700 * @param <S> a {@link RadioSource} type.
1701 * @return a new robust 2D position radio source estimator.
1702 * @throws IllegalArgumentException if readings are not valid.
1703 */
1704 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1705 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1706 final Double initialTransmittedPowerdBm,
1707 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1708 return create(readings, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
1709 }
1710
1711 /**
1712 * Creates a robust 2D position radio source estimator using
1713 * default method.
1714 *
1715 * @param readings signal readings belonging to the same radio source.
1716 * @param initialPosition initial position to start the estimation of radio
1717 * source position.
1718 * @param initialTransmittedPowerdBm initial transmitted power to start the
1719 * estimation of radio source transmitted power
1720 * (expressed in dBm's).
1721 * @param <S> a {@link RadioSource} type.
1722 * @return a new robust 2D position radio source estimator.
1723 * @throws IllegalArgumentException if readings are not valid.
1724 */
1725 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1726 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
1727 final Double initialTransmittedPowerdBm) {
1728 return create(readings, initialPosition, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
1729 }
1730
1731 /**
1732 * Creates a robust 2D position radio source estimator using
1733 * default method.
1734 *
1735 * @param initialPosition initial position to start the estimation of radio
1736 * source position.
1737 * @param initialTransmittedPowerdBm initial transmitted power to start the
1738 * estimation of radio source transmitted power
1739 * (expressed in dBm's).
1740 * @param <S> a {@link RadioSource} type.
1741 * @return a new robust 2D position radio source estimator.
1742 */
1743 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1744 final Point2D initialPosition, final Double initialTransmittedPowerdBm) {
1745 return create(initialPosition, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
1746 }
1747
1748 /**
1749 * Creates a robust 2D position radio source estimator using
1750 * default method.
1751 *
1752 * @param initialPosition initial position to start the estimation of radio
1753 * source position.
1754 * @param initialTransmittedPowerdBm initial transmitted power to start the
1755 * estimation of radio source transmitted power
1756 * (expressed in dBm's).
1757 * @param listener listener in charge of attending events raised by this instance.
1758 * @param <S> a {@link RadioSource} type.
1759 * @return a new robust 2D position radio source estimator.
1760 */
1761 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1762 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1763 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1764 return create(initialPosition, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
1765 }
1766
1767 /**
1768 * Creates a robust 2D position radio source estimator using
1769 * default method.
1770 *
1771 * @param readings signal readings belonging to the same radio source.
1772 * @param initialPosition initial position to start the estimation of radio
1773 * source position.
1774 * @param initialTransmittedPowerdBm initial transmitted power to start the
1775 * estimation of radio source transmitted power
1776 * (expressed in dBm's).
1777 * @param listener listener in charge of attending events raised by this instance.
1778 * @param <S> a {@link RadioSource} type.
1779 * @return a new robust 2D position radio source estimator.
1780 * @throws IllegalArgumentException if readings are not valid.
1781 */
1782 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1783 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
1784 final Double initialTransmittedPowerdBm,
1785 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1786 return create(readings, initialPosition, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
1787 }
1788
1789 /**
1790 * Creates a robust 2D position radio source estimator using
1791 * default method.
1792 *
1793 * @param readings signal readings belonging to the same radio source.
1794 * @param initialPosition initial position to start the estimation of radio
1795 * source position.
1796 * @param initialTransmittedPowerdBm initial transmitted power to start the
1797 * estimation of radio source transmitted power
1798 * (expressed in dBm's).
1799 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1800 * @param <S> a {@link RadioSource} type.
1801 * @return a new robust 2D position radio source estimator.
1802 * @throws IllegalArgumentException if readings are not valid.
1803 */
1804 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1805 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
1806 final Double initialTransmittedPowerdBm, final double initialPathLossExponent) {
1807 return create(readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent,
1808 DEFAULT_ROBUST_METHOD);
1809 }
1810
1811 /**
1812 * Creates a robust 2D position radio source estimator using
1813 * default method.
1814 *
1815 * @param initialPosition initial position to start the estimation of radio
1816 * source position.
1817 * @param initialTransmittedPowerdBm initial transmitted power to start the
1818 * estimation of radio source transmitted power
1819 * (expressed in dBm's).
1820 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1821 * @param <S> a {@link RadioSource} type.
1822 * @return a new robust 2D position radio source estimator.
1823 */
1824 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1825 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1826 final double initialPathLossExponent) {
1827 return create(initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, DEFAULT_ROBUST_METHOD);
1828 }
1829
1830 /**
1831 * Creates a robust 2D position radio source estimator using
1832 * default method.
1833 *
1834 * @param initialPosition initial position to start the estimation of radio
1835 * source position.
1836 * @param initialTransmittedPowerdBm initial transmitted power to start the
1837 * estimation of radio source transmitted power
1838 * (expressed in dBm's).
1839 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1840 * @param listener listener in charge of attending events raised by this instance.
1841 * @param <S> a {@link RadioSource} type.
1842 * @return a new robust 2D position radio source estimator.
1843 */
1844 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1845 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
1846 final double initialPathLossExponent,
1847 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1848 return create(initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener,
1849 DEFAULT_ROBUST_METHOD);
1850 }
1851
1852 /**
1853 * Creates a robust 2D position radio source estimator using
1854 * default method.
1855 *
1856 * @param readings signal readings belonging to the same radio source.
1857 * @param initialPosition initial position to start the estimation of radio
1858 * source position.
1859 * @param initialTransmittedPowerdBm initial transmitted power to start the
1860 * estimation of radio source transmitted power
1861 * (expressed in dBm's).
1862 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
1863 * @param listener listener in charge of attending events raised by this instance.
1864 * @param <S> a {@link RadioSource} type.
1865 * @return a new robust 2D position radio source estimator.
1866 * @throws IllegalArgumentException if readings are not valid.
1867 */
1868 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1869 final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings, final Point2D initialPosition,
1870 final Double initialTransmittedPowerdBm, final double initialPathLossExponent,
1871 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1872 return create(readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener,
1873 DEFAULT_ROBUST_METHOD);
1874 }
1875
1876 /**
1877 * Creates a robust 2D position radio source estimator using
1878 * default method.
1879 *
1880 * @param qualityScores quality scores corresponding to each provided
1881 * sample. The larger the score value the better
1882 * the quality of the sample.
1883 * @param <S> a {@link RadioSource} type.
1884 * @return a new robust 2D position radio source estimator.
1885 */
1886 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1887 final double[] qualityScores) {
1888 return create(qualityScores, DEFAULT_ROBUST_METHOD);
1889 }
1890
1891 /**
1892 * Creates a robust 2D position radio source estimator using
1893 * default method.
1894 *
1895 * @param qualityScores quality scores corresponding to each provided
1896 * sample. The larger the score value the better
1897 * the quality of the sample.
1898 * @param readings signal readings belonging to the same radio source.
1899 * @param <S> a {@link RadioSource} type.
1900 * @return a new robust 2D position radio source estimator.
1901 * @throws IllegalArgumentException if readings are not valid.
1902 */
1903 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1904 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings) {
1905 return create(qualityScores, readings, DEFAULT_ROBUST_METHOD);
1906 }
1907
1908 /**
1909 * Creates a robust 2D position radio source estimator using
1910 * default method.
1911 *
1912 * @param qualityScores quality scores corresponding to each provided
1913 * sample. The larger the score value the better
1914 * the quality of the sample.
1915 * @param listener listener in charge of attending events raised by this instance.
1916 * @param <S> a {@link RadioSource} type.
1917 * @return a new robust 2D position radio source estimator.
1918 */
1919 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1920 final double[] qualityScores, final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1921 return create(qualityScores, listener, DEFAULT_ROBUST_METHOD);
1922 }
1923
1924 /**
1925 * Creates a robust 2D position radio source estimator using
1926 * default method.
1927 *
1928 * @param qualityScores quality scores corresponding to each provided
1929 * sample. The larger the score value the better
1930 * the quality of the sample.
1931 * @param readings signal readings belonging to the same radio source.
1932 * @param listener listener in charge of attending events raised by this instance.
1933 * @param <S> a {@link RadioSource} type.
1934 * @return a new robust 2D position radio source estimator.
1935 * @throws IllegalArgumentException if readings are not valid.
1936 */
1937 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1938 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1939 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1940 return create(qualityScores, readings, listener, DEFAULT_ROBUST_METHOD);
1941 }
1942
1943 /**
1944 * Creates a robust 2D position radio source estimator using
1945 * default method.
1946 *
1947 * @param qualityScores quality scores corresponding to each provided
1948 * sample. The larger the score value the better
1949 * the quality of the sample.
1950 * @param readings signal readings belonging to the same radio source.
1951 * @param initialPosition initial position to start the estimation of radio
1952 * source position.
1953 * @param <S> a {@link RadioSource} type.
1954 * @return a new robust 2D position radio source estimator.
1955 * @throws IllegalArgumentException if readings are not valid.
1956 */
1957 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1958 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
1959 final Point2D initialPosition) {
1960 return create(qualityScores, readings, initialPosition, DEFAULT_ROBUST_METHOD);
1961 }
1962
1963 /**
1964 * Creates a robust 2D position radio source estimator using
1965 * default method.
1966 *
1967 * @param qualityScores quality scores corresponding to each provided
1968 * sample. The larger the score value the better
1969 * the quality of the sample.
1970 * @param initialPosition initial position to start the estimation of radio
1971 * source position.
1972 * @param <S> a {@link RadioSource} type.
1973 * @return a new robust 2D position radio source estimator.
1974 */
1975 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1976 final double[] qualityScores, final Point2D initialPosition) {
1977 return create(qualityScores, initialPosition, DEFAULT_ROBUST_METHOD);
1978 }
1979
1980 /**
1981 * Creates a robust 2D position radio source estimator using
1982 * default method.
1983 *
1984 * @param qualityScores quality scores corresponding to each provided
1985 * sample. The larger the score value the better
1986 * the quality of the sample.
1987 * @param initialPosition initial position to start the estimation of radio
1988 * source position.
1989 * @param listener listener in charge of attending events raised by this instance.
1990 * @param <S> a {@link RadioSource} type.
1991 * @return a new robust 2D position radio source estimator.
1992 */
1993 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
1994 final double[] qualityScores, final Point2D initialPosition,
1995 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
1996 return create(qualityScores, initialPosition, listener, DEFAULT_ROBUST_METHOD);
1997 }
1998
1999 /**
2000 * Creates a robust 2D position radio source estimator using
2001 * default method.
2002 *
2003 * @param qualityScores quality scores corresponding to each provided
2004 * sample. The larger the score value the better
2005 * the quality of the sample.
2006 * @param readings signal readings belonging to the same radio source.
2007 * @param initialPosition initial position to start the estimation of radio
2008 * source position.
2009 * @param listener listener in charge of attending events raised by this instance
2010 * @param <S> a {@link RadioSource} type.
2011 * @return a new robust 2D position radio source estimator.
2012 * @throws IllegalArgumentException if readings are not valid.
2013 */
2014 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2015 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2016 final Point2D initialPosition,
2017 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2018 return create(qualityScores, readings, initialPosition, listener, DEFAULT_ROBUST_METHOD);
2019 }
2020
2021 /**
2022 * Creates a robust 2D position radio source estimator using
2023 * default method.
2024 *
2025 * @param qualityScores quality scores corresponding to each provided
2026 * sample. The larger the score value the better
2027 * the quality of the sample.
2028 * @param initialTransmittedPowerdBm initial transmitted power to start the
2029 * estimation of radio source transmitted power
2030 * (expressed in dBm's).
2031 * @param <S> a {@link RadioSource} type.
2032 * @return a new robust 2D position radio source estimator.
2033 */
2034 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2035 final double[] qualityScores, final Double initialTransmittedPowerdBm) {
2036 return create(qualityScores, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
2037 }
2038
2039 /**
2040 * Creates a robust 2D position radio source estimator using
2041 * default method.
2042 *
2043 * @param qualityScores quality scores corresponding to each provided
2044 * sample. The larger the score value the better
2045 * the quality of the sample.
2046 * @param readings signal readings belonging to the same radio source.
2047 * @param initialTransmittedPowerdBm initial transmitted power to start the
2048 * estimation of radio source transmitted power
2049 * (expressed in dBm's).
2050 * @param <S> a {@link RadioSource} type.
2051 * @return a new robust 2D position radio source estimator.
2052 * @throws IllegalArgumentException if readings are not valid.
2053 */
2054 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2055 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2056 final Double initialTransmittedPowerdBm) {
2057 return create(qualityScores, readings, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
2058 }
2059
2060 /**
2061 * Creates a robust 2D position radio source estimator using
2062 * default method.
2063 *
2064 * @param qualityScores quality scores corresponding to each provided
2065 * sample. The larger the score value the better
2066 * the quality of the sample.
2067 * @param initialTransmittedPowerdBm initial transmitted power to start the
2068 * estimation of radio source transmitted power
2069 * (expressed in dBm's)
2070 * @param listener listener in charge of attending events raised by this instance.
2071 * @param <S> a {@link RadioSource} type.
2072 * @return a new robust 2D position radio source estimator.
2073 */
2074 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2075 final double[] qualityScores, final Double initialTransmittedPowerdBm,
2076 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2077 return create(qualityScores, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
2078 }
2079
2080 /**
2081 * Creates a robust 2D position radio source estimator using
2082 * default method.
2083 *
2084 * @param qualityScores quality scores corresponding to each provided
2085 * sample. The larger the score value the better
2086 * the quality of the sample.
2087 * @param readings signal readings belonging to the same radio source.
2088 * @param initialTransmittedPowerdBm initial transmitted power to start the
2089 * estimation of radio source transmitted power
2090 * (expressed in dBm's)
2091 * @param listener listener in charge of attending events raised by this instance.
2092 * @param <S> a {@link RadioSource} type.
2093 * @return a new robust 2D position radio source estimator.
2094 * @throws IllegalArgumentException if readings are not valid.
2095 */
2096 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2097 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2098 final Double initialTransmittedPowerdBm,
2099 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2100 return create(qualityScores, readings, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
2101 }
2102
2103 /**
2104 * Creates a robust 2D position radio source estimator using
2105 * default method.
2106 *
2107 * @param qualityScores quality scores corresponding to each provided
2108 * sample. The larger the score value the better
2109 * the quality of the sample.
2110 * @param readings signal readings belonging to the same radio source.
2111 * @param initialPosition initial position to start the estimation of radio
2112 * source position.
2113 * @param initialTransmittedPowerdBm initial transmitted power to start the
2114 * estimation of radio source transmitted power
2115 * (expressed in dBm's).
2116 * @param <S> a {@link RadioSource} type.
2117 * @return a new robust 2D position radio source estimator.
2118 * @throws IllegalArgumentException if readings are not valid.
2119 */
2120 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2121 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2122 final Point2D initialPosition, final Double initialTransmittedPowerdBm) {
2123 return create(qualityScores, readings, initialPosition, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
2124 }
2125
2126 /**
2127 * Creates a robust 2D position radio source estimator using
2128 * default method.
2129 *
2130 * @param qualityScores quality scores corresponding to each provided
2131 * sample. The larger the score value the better
2132 * the quality of the sample.
2133 * @param initialPosition initial position to start the estimation of radio
2134 * source position.
2135 * @param initialTransmittedPowerdBm initial transmitted power to start the
2136 * estimation of radio source transmitted power
2137 * (expressed in dBm's).
2138 * @param <S> a {@link RadioSource} type.
2139 * @return a new robust 2D position radio source estimator.
2140 */
2141 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2142 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm) {
2143 return create(qualityScores, initialPosition, initialTransmittedPowerdBm, DEFAULT_ROBUST_METHOD);
2144 }
2145
2146 /**
2147 * Creates a robust 2D position radio source estimator using
2148 * default method.
2149 *
2150 * @param qualityScores quality scores corresponding to each provided
2151 * sample. The larger the score value the better
2152 * the quality of the sample.
2153 * @param initialPosition initial position to start the estimation of radio
2154 * source position.
2155 * @param initialTransmittedPowerdBm initial transmitted power to start the
2156 * estimation of radio source transmitted power
2157 * (expressed in dBm's).
2158 * @param listener listener in charge of attending events raised by this instance.
2159 * @param <S> a {@link RadioSource} type.
2160 * @return a new robust 2D position radio source estimator.
2161 */
2162 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2163 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2164 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2165 return create(qualityScores, initialPosition, initialTransmittedPowerdBm, listener, DEFAULT_ROBUST_METHOD);
2166 }
2167
2168 /**
2169 * Creates a robust 2D position radio source estimator using
2170 * default method.
2171 *
2172 * @param qualityScores quality scores corresponding to each provided
2173 * sample. The larger the score value the better
2174 * the quality of the sample.
2175 * @param readings signal readings belonging to the same radio source.
2176 * @param initialPosition initial position to start the estimation of radio
2177 * source position.
2178 * @param initialTransmittedPowerdBm initial transmitted power to start the
2179 * estimation of radio source transmitted power
2180 * (expressed in dBm's).
2181 * @param listener listener in charge of attending events raised by this instance.
2182 * @param <S> a {@link RadioSource} type.
2183 * @return a new robust 2D position radio source estimator.
2184 * @throws IllegalArgumentException if readings are not valid.
2185 */
2186 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2187 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2188 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2189 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2190 return create(qualityScores, readings, initialPosition, initialTransmittedPowerdBm, listener,
2191 DEFAULT_ROBUST_METHOD);
2192 }
2193
2194 /**
2195 * Creates a robust 2D position radio source estimator using
2196 * default method.
2197 *
2198 * @param qualityScores quality scores corresponding to each provided
2199 * sample. The larger the score value the better
2200 * the quality of the sample.
2201 * @param readings signal readings belonging to the same radio source.
2202 * @param initialPosition initial position to start the estimation of radio
2203 * source position.
2204 * @param initialTransmittedPowerdBm initial transmitted power to start the
2205 * estimation of radio source transmitted power
2206 * (expressed in dBm's).
2207 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
2208 * @param <S> a {@link RadioSource} type.
2209 * @return a new robust 2D position radio source estimator.
2210 * @throws IllegalArgumentException if readings are not valid.
2211 */
2212 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2213 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2214 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2215 final double initialPathLossExponent) {
2216 return create(qualityScores, readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent,
2217 DEFAULT_ROBUST_METHOD);
2218 }
2219
2220 /**
2221 * Creates a robust 2D position radio source estimator using
2222 * default method.
2223 *
2224 * @param qualityScores quality scores corresponding to each provided
2225 * sample. The larger the score value the better
2226 * the quality of the sample.
2227 * @param initialPosition initial position to start the estimation of radio
2228 * source position.
2229 * @param initialTransmittedPowerdBm initial transmitted power to start the
2230 * estimation of radio source transmitted power
2231 * (expressed in dBm's).
2232 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
2233 * @param <S> a {@link RadioSource} type.
2234 * @return a new robust 2D position radio source estimator.
2235 */
2236 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2237 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2238 final double initialPathLossExponent) {
2239 return create(qualityScores, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent,
2240 DEFAULT_ROBUST_METHOD);
2241 }
2242
2243 /**
2244 * Creates a robust 2D position radio source estimator using
2245 * default method.
2246 *
2247 * @param qualityScores quality scores corresponding to each provided
2248 * sample. The larger the score value the better
2249 * the quality of the sample.
2250 * @param initialPosition initial position to start the estimation of radio
2251 * source position.
2252 * @param initialTransmittedPowerdBm initial transmitted power to start the
2253 * estimation of radio source transmitted power
2254 * (expressed in dBm's).
2255 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
2256 * @param listener listener in charge of attending events raised by this instance.
2257 * @param <S> a {@link RadioSource} type.
2258 * @return a new robust 2D position radio source estimator.
2259 */
2260 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2261 final double[] qualityScores, final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2262 final double initialPathLossExponent,
2263 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2264 return create(qualityScores, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent, listener,
2265 DEFAULT_ROBUST_METHOD);
2266 }
2267
2268 /**
2269 * Creates a robust 2D position radio source estimator using
2270 * default method.
2271 *
2272 * @param qualityScores quality scores corresponding to each provided
2273 * sample. The larger the score value the better
2274 * the quality of the sample.
2275 * @param readings signal readings belonging to the same radio source.
2276 * @param initialPosition initial position to start the estimation of radio
2277 * source position.
2278 * @param initialTransmittedPowerdBm initial transmitted power to start the
2279 * estimation of radio source transmitted power
2280 * (expressed in dBm's).
2281 * @param initialPathLossExponent initial path loss exponent. A typical value is 2.0.
2282 * @param listener listener in charge of attending events raised by this instance.
2283 * @param <S> a {@link RadioSource} type.
2284 * @return a new robust 2D position radio source estimator.
2285 * @throws IllegalArgumentException if readings are not valid.
2286 */
2287 public static <S extends RadioSource> RobustRangingAndRssiRadioSourceEstimator2D<S> create(
2288 final double[] qualityScores, final List<? extends RangingAndRssiReadingLocated<S, Point2D>> readings,
2289 final Point2D initialPosition, final Double initialTransmittedPowerdBm,
2290 final double initialPathLossExponent,
2291 final RobustRangingAndRssiRadioSourceEstimatorListener<S, Point2D> listener) {
2292 return create(qualityScores, readings, initialPosition, initialTransmittedPowerdBm, initialPathLossExponent,
2293 listener, DEFAULT_ROBUST_METHOD);
2294 }
2295
2296 /**
2297 * Indicates whether an homogeneous linear solver is used to estimate an initial
2298 * position for the internal ranging radio source estimator.
2299 *
2300 * @return true if homogeneous linear solver is used, false if an inhomogeneous linear
2301 * one is used instead.
2302 */
2303 @Override
2304 public boolean isHomogeneousRangingLinearSolverUsed() {
2305 return innerEstimator.isHomogeneousRangingLinearSolverUsed();
2306 }
2307
2308 /**
2309 * Specifies whether an homogeneous linear solver is used to estimate an initial
2310 * position for the internal ranging radio source estimator.
2311 *
2312 * @param useHomogeneousLinearSolver true if homogeneous linear solver is used, false
2313 * if an inhomogeneous linear one is used instead.
2314 * @throws LockedException if estimator is locked.
2315 */
2316 @Override
2317 public void setHomogeneousRangingLinearSolverUsed(final boolean useHomogeneousLinearSolver) throws LockedException {
2318 if (isLocked()) {
2319 throw new LockedException();
2320 }
2321
2322 innerEstimator.setHomogeneousRangingLinearSolverUsed(useHomogeneousLinearSolver);
2323 }
2324
2325 /**
2326 * Gets minimum required number of readings to estimate
2327 * power, position and path-loss exponent.
2328 * This value depends on the number of parameters to
2329 * be estimated, but for position only, this is 3
2330 * readings.
2331 *
2332 * @return minimum required number of readings.
2333 */
2334 @Override
2335 public int getMinReadings() {
2336 var minReadings = Point2D.POINT2D_INHOMOGENEOUS_COORDINATES_LENGTH;
2337 if (isTransmittedPowerEstimationEnabled()) {
2338 minReadings++;
2339 }
2340 if (isPathLossEstimationEnabled()) {
2341 minReadings++;
2342 }
2343 return ++minReadings;
2344 }
2345
2346 /**
2347 * Gets number of dimensions of position points.
2348 *
2349 * @return always returns 2 dimensions.
2350 */
2351 @Override
2352 public int getNumberOfDimensions() {
2353 return innerEstimator.getNumberOfDimensions();
2354 }
2355
2356 /**
2357 * Gets estimated located radio source with estimated transmitted power.
2358 *
2359 * @return estimated located radio source with estimated transmitted power or null.
2360 */
2361 @Override
2362 @SuppressWarnings("unchecked")
2363 public RadioSourceWithPowerAndLocated<Point2D> getEstimatedRadioSource() {
2364 final var readings = getReadings();
2365 if (readings == null || readings.isEmpty()) {
2366 return null;
2367 }
2368 final var source = readings.get(0).getSource();
2369
2370 final var estimatedPosition = getEstimatedPosition();
2371 if (estimatedPosition == null) {
2372 return null;
2373 }
2374
2375 final var estimatedPositionCovariance = getEstimatedPositionCovariance();
2376
2377 final var transmittedPowerVariance = getEstimatedTransmittedPowerVariance();
2378 final var transmittedPowerStandardDeviation = transmittedPowerVariance != null
2379 ? Math.sqrt(transmittedPowerVariance) : null;
2380
2381 final var pathlossExponentVariance = getEstimatedPathLossExponentVariance();
2382 final var pathlossExponentStandardDeviation = pathlossExponentVariance != null
2383 ? Math.sqrt(pathlossExponentVariance) : null;
2384
2385 if (source instanceof WifiAccessPoint accessPoint) {
2386 return new WifiAccessPointWithPowerAndLocated2D(accessPoint.getBssid(), source.getFrequency(),
2387 accessPoint.getSsid(), getEstimatedTransmittedPowerdBm(), transmittedPowerStandardDeviation,
2388 getEstimatedPathLossExponent(), pathlossExponentStandardDeviation, estimatedPosition,
2389 estimatedPositionCovariance);
2390 } else if (source instanceof Beacon beacon) {
2391 return new BeaconWithPowerAndLocated2D(beacon.getIdentifiers(), getEstimatedTransmittedPowerdBm(),
2392 beacon.getFrequency(), beacon.getBluetoothAddress(), beacon.getBeaconTypeCode(),
2393 beacon.getManufacturer(), beacon.getServiceUuid(), beacon.getBluetoothName(),
2394 getEstimatedPathLossExponent(), transmittedPowerStandardDeviation,
2395 pathlossExponentStandardDeviation, estimatedPosition, estimatedPositionCovariance);
2396 } else {
2397 return null;
2398 }
2399 }
2400
2401 /**
2402 * Solves preliminary solution for a subset of samples.
2403 *
2404 * @param samplesIndices indices of subset samples.
2405 * @param solutions instance where solution will be stored.
2406 */
2407 @Override
2408 protected void solvePreliminarySolutions(final int[] samplesIndices, final List<Solution<Point2D>> solutions) {
2409
2410 try {
2411 innerReadings.clear();
2412 for (final var samplesIndex : samplesIndices) {
2413 innerReadings.add(readings.get(samplesIndex));
2414 }
2415
2416 // initial transmitted power and position might or might not be available
2417 innerEstimator.setInitialTransmittedPowerdBm(initialTransmittedPowerdBm);
2418 innerEstimator.setInitialPosition(initialPosition);
2419 innerEstimator.setInitialPathLossExponent(initialPathLossExponent);
2420
2421 innerEstimator.setTransmittedPowerEstimationEnabled(transmittedPowerEstimationEnabled);
2422 innerEstimator.setPathLossEstimationEnabled(pathLossEstimationEnabled);
2423
2424 innerEstimator.setReadings(innerReadings);
2425
2426 // indicates whether readings position covariances must be taken into account
2427 innerEstimator.setUseReadingPositionCovariances(useReadingPositionCovariances);
2428
2429 innerEstimator.estimate();
2430
2431 final var estimatedPosition = innerEstimator.getEstimatedPosition();
2432 final var estimatedTransmittedPowerdBm = innerEstimator.getEstimatedTransmittedPowerdBm();
2433 final var estimatedPathLossExponent = innerEstimator.getEstimatedPathLossExponent();
2434 solutions.add(new Solution<>(estimatedPosition, estimatedTransmittedPowerdBm, estimatedPathLossExponent));
2435 } catch (final NavigationException ignore) {
2436 // if anything fails, no solution is added
2437 }
2438 }
2439
2440 /**
2441 * Attempts to refine estimated position and transmitted power contained in
2442 * provided solution if refinement is requested.
2443 * This method sets a refined result and transmitted power or provided input
2444 * result if refinement is not requested or has failed.
2445 * If refinement is enabled, and it is requested to keep covariance, this method
2446 * will also keep covariance of refined result.
2447 * solution if not requested or refinement failed.
2448 *
2449 * @param result result to be refined.
2450 */
2451 protected void attemptRefine(final Solution<Point2D> result) {
2452 final var initialPosition = result.getEstimatedPosition();
2453 final var initialTransmittedPowerdBm = result.getEstimatedTransmittedPowerdBm();
2454 final var initialPathLossExponent = result.getEstimatedPathLossExponent();
2455
2456 if (refineResult && inliersData != null) {
2457 final var inliers = inliersData.getInliers();
2458 final var nSamples = readings.size();
2459
2460 innerReadings.clear();
2461
2462 for (var i = 0; i < nSamples; i++) {
2463 if (inliers.get(i)) {
2464 // sample is inlier
2465 innerReadings.add(readings.get(i));
2466 }
2467 }
2468
2469 try {
2470 innerEstimator.setInitialPosition(initialPosition);
2471 innerEstimator.setInitialTransmittedPowerdBm(initialTransmittedPowerdBm);
2472 innerEstimator.setInitialPathLossExponent(initialPathLossExponent);
2473 innerEstimator.setTransmittedPowerEstimationEnabled(transmittedPowerEstimationEnabled);
2474 innerEstimator.setPathLossEstimationEnabled(pathLossEstimationEnabled);
2475 innerEstimator.setReadings(innerReadings);
2476 innerEstimator.setUseReadingPositionCovariances(useReadingPositionCovariances);
2477
2478 innerEstimator.estimate();
2479
2480 final var cov = innerEstimator.getEstimatedCovariance();
2481 if (keepCovariance && cov != null) {
2482 // keep covariance
2483 covariance = cov;
2484
2485 final var dims = getNumberOfDimensions();
2486 var pos = 0;
2487
2488 final var d = dims - 1;
2489 if (estimatedPositionCovariance == null) {
2490 estimatedPositionCovariance = covariance.getSubmatrix(0, 0, d, d);
2491 } else {
2492 covariance.getSubmatrix(0, 0, d, d, estimatedPositionCovariance);
2493 }
2494 pos += dims;
2495
2496 if (transmittedPowerEstimationEnabled) {
2497 // transmitted power estimation enabled
2498 estimatedTransmittedPowerVariance = covariance.getElementAt(pos, pos);
2499 pos++;
2500 } else {
2501 // transmitted power estimation disabled
2502 estimatedTransmittedPowerVariance = null;
2503 }
2504
2505 if (pathLossEstimationEnabled) {
2506 // path-loss exponent estimation enabled
2507 estimatedPathLossExponentVariance = covariance.getElementAt(pos, pos);
2508 } else {
2509 // path-loss exponent estimation disabled
2510 estimatedPathLossExponentVariance = null;
2511 }
2512 } else {
2513 covariance = null;
2514 estimatedPositionCovariance = null;
2515 estimatedTransmittedPowerVariance = null;
2516 estimatedPathLossExponentVariance = null;
2517 }
2518
2519 estimatedPosition = innerEstimator.getEstimatedPosition();
2520 estimatedTransmittedPowerdBm = innerEstimator.getEstimatedTransmittedPowerdBm();
2521 estimatedPathLossExponent = innerEstimator.getEstimatedPathLossExponent();
2522 } catch (final Exception e) {
2523 // refinement failed, so we return input value, and covariance
2524 // becomes unavailable
2525 covariance = null;
2526 estimatedPositionCovariance = null;
2527 estimatedTransmittedPowerVariance = null;
2528 estimatedPathLossExponentVariance = null;
2529
2530 estimatedPosition = initialPosition;
2531 estimatedTransmittedPowerdBm = initialTransmittedPowerdBm;
2532 estimatedPathLossExponent = initialPathLossExponent;
2533 }
2534 } else {
2535 covariance = null;
2536 estimatedPositionCovariance = null;
2537 estimatedTransmittedPowerVariance = null;
2538 estimatedPathLossExponentVariance = null;
2539
2540 estimatedPosition = initialPosition;
2541 estimatedTransmittedPowerdBm = initialTransmittedPowerdBm;
2542 estimatedPathLossExponent = initialPathLossExponent;
2543 }
2544 }
2545 }