YARP
Yet Another Robot Platform
BatteryState.h
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// This is an automatically generated file.
7
8// Generated from the following "sensor_msgs/BatteryState" msg definition:
9//
10// # Constants are chosen to match the enums in the linux kernel
11// # defined in include/linux/power_supply.h as of version 3.7
12// # The one difference is for style reasons the constants are
13// # all uppercase not mixed case.
14//
15// # Power supply status constants
16// uint8 POWER_SUPPLY_STATUS_UNKNOWN = 0
17// uint8 POWER_SUPPLY_STATUS_CHARGING = 1
18// uint8 POWER_SUPPLY_STATUS_DISCHARGING = 2
19// uint8 POWER_SUPPLY_STATUS_NOT_CHARGING = 3
20// uint8 POWER_SUPPLY_STATUS_FULL = 4
21//
22// # Power supply health constants
23// uint8 POWER_SUPPLY_HEALTH_UNKNOWN = 0
24// uint8 POWER_SUPPLY_HEALTH_GOOD = 1
25// uint8 POWER_SUPPLY_HEALTH_OVERHEAT = 2
26// uint8 POWER_SUPPLY_HEALTH_DEAD = 3
27// uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4
28// uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5
29// uint8 POWER_SUPPLY_HEALTH_COLD = 6
30// uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7
31// uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8
32//
33// # Power supply technology (chemistry) constants
34// uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0
35// uint8 POWER_SUPPLY_TECHNOLOGY_NIMH = 1
36// uint8 POWER_SUPPLY_TECHNOLOGY_LION = 2
37// uint8 POWER_SUPPLY_TECHNOLOGY_LIPO = 3
38// uint8 POWER_SUPPLY_TECHNOLOGY_LIFE = 4
39// uint8 POWER_SUPPLY_TECHNOLOGY_NICD = 5
40// uint8 POWER_SUPPLY_TECHNOLOGY_LIMN = 6
41//
42// Header header
43// float32 voltage # Voltage in Volts (Mandatory)
44// float32 current # Negative when discharging (A) (If unmeasured NaN)
45// float32 charge # Current charge in Ah (If unmeasured NaN)
46// float32 capacity # Capacity in Ah (last full capacity) (If unmeasured NaN)
47// float32 design_capacity # Capacity in Ah (design capacity) (If unmeasured NaN)
48// float32 percentage # Charge percentage on 0 to 1 range (If unmeasured NaN)
49// uint8 power_supply_status # The charging status as reported. Values defined above
50// uint8 power_supply_health # The battery health metric. Values defined above
51// uint8 power_supply_technology # The battery chemistry. Values defined above
52// bool present # True if the battery is present
53//
54// float32[] cell_voltage # An array of individual cell voltages for each cell in the pack
55// # If individual voltages unknown but number of cells known set each to NaN
56// string location # The location into which the battery is inserted. (slot number or plug)
57// string serial_number # The best approximation of the battery serial number
58// Instances of this class can be read and written with YARP ports,
59// using a ROS-compatible format.
60
61#ifndef YARP_ROSMSG_sensor_msgs_BatteryState_h
62#define YARP_ROSMSG_sensor_msgs_BatteryState_h
63
64#include <yarp/os/Wire.h>
65#include <yarp/os/Type.h>
67#include <string>
68#include <vector>
70
71namespace yarp {
72namespace rosmsg {
73namespace sensor_msgs {
74
76{
77public:
78 static const std::uint8_t POWER_SUPPLY_STATUS_UNKNOWN = 0;
79 static const std::uint8_t POWER_SUPPLY_STATUS_CHARGING = 1;
80 static const std::uint8_t POWER_SUPPLY_STATUS_DISCHARGING = 2;
81 static const std::uint8_t POWER_SUPPLY_STATUS_NOT_CHARGING = 3;
82 static const std::uint8_t POWER_SUPPLY_STATUS_FULL = 4;
83 static const std::uint8_t POWER_SUPPLY_HEALTH_UNKNOWN = 0;
84 static const std::uint8_t POWER_SUPPLY_HEALTH_GOOD = 1;
85 static const std::uint8_t POWER_SUPPLY_HEALTH_OVERHEAT = 2;
86 static const std::uint8_t POWER_SUPPLY_HEALTH_DEAD = 3;
87 static const std::uint8_t POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4;
88 static const std::uint8_t POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5;
89 static const std::uint8_t POWER_SUPPLY_HEALTH_COLD = 6;
90 static const std::uint8_t POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7;
91 static const std::uint8_t POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8;
92 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0;
93 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_NIMH = 1;
94 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_LION = 2;
95 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_LIPO = 3;
96 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_LIFE = 4;
97 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_NICD = 5;
98 static const std::uint8_t POWER_SUPPLY_TECHNOLOGY_LIMN = 6;
100 yarp::conf::float32_t voltage;
101 yarp::conf::float32_t current;
103 yarp::conf::float32_t capacity;
104 yarp::conf::float32_t design_capacity;
105 yarp::conf::float32_t percentage;
106 std::uint8_t power_supply_status;
107 std::uint8_t power_supply_health;
108 std::uint8_t power_supply_technology;
109 bool present;
110 std::vector<yarp::conf::float32_t> cell_voltage;
111 std::string location;
112 std::string serial_number;
113
114 BatteryState() :
115 header(),
116 voltage(0.0f),
117 current(0.0f),
118 charge(0.0f),
119 capacity(0.0f),
120 design_capacity(0.0f),
121 percentage(0.0f),
122 power_supply_status(0),
123 power_supply_health(0),
124 power_supply_technology(0),
125 present(false),
126 cell_voltage(),
127 location(""),
128 serial_number("")
129 {
130 }
131
132 void clear()
133 {
134 // *** POWER_SUPPLY_STATUS_UNKNOWN ***
135
136 // *** POWER_SUPPLY_STATUS_CHARGING ***
137
138 // *** POWER_SUPPLY_STATUS_DISCHARGING ***
139
140 // *** POWER_SUPPLY_STATUS_NOT_CHARGING ***
141
142 // *** POWER_SUPPLY_STATUS_FULL ***
143
144 // *** POWER_SUPPLY_HEALTH_UNKNOWN ***
145
146 // *** POWER_SUPPLY_HEALTH_GOOD ***
147
148 // *** POWER_SUPPLY_HEALTH_OVERHEAT ***
149
150 // *** POWER_SUPPLY_HEALTH_DEAD ***
151
152 // *** POWER_SUPPLY_HEALTH_OVERVOLTAGE ***
153
154 // *** POWER_SUPPLY_HEALTH_UNSPEC_FAILURE ***
155
156 // *** POWER_SUPPLY_HEALTH_COLD ***
157
158 // *** POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE ***
159
160 // *** POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE ***
161
162 // *** POWER_SUPPLY_TECHNOLOGY_UNKNOWN ***
163
164 // *** POWER_SUPPLY_TECHNOLOGY_NIMH ***
165
166 // *** POWER_SUPPLY_TECHNOLOGY_LION ***
167
168 // *** POWER_SUPPLY_TECHNOLOGY_LIPO ***
169
170 // *** POWER_SUPPLY_TECHNOLOGY_LIFE ***
171
172 // *** POWER_SUPPLY_TECHNOLOGY_NICD ***
173
174 // *** POWER_SUPPLY_TECHNOLOGY_LIMN ***
175
176 // *** header ***
177 header.clear();
178
179 // *** voltage ***
180 voltage = 0.0f;
181
182 // *** current ***
183 current = 0.0f;
184
185 // *** charge ***
186 charge = 0.0f;
187
188 // *** capacity ***
189 capacity = 0.0f;
190
191 // *** design_capacity ***
192 design_capacity = 0.0f;
193
194 // *** percentage ***
195 percentage = 0.0f;
196
197 // *** power_supply_status ***
198 power_supply_status = 0;
199
200 // *** power_supply_health ***
201 power_supply_health = 0;
202
203 // *** power_supply_technology ***
204 power_supply_technology = 0;
205
206 // *** present ***
207 present = false;
208
209 // *** cell_voltage ***
210 cell_voltage.clear();
211
212 // *** location ***
213 location = "";
214
215 // *** serial_number ***
216 serial_number = "";
217 }
218
219 bool readBare(yarp::os::ConnectionReader& connection) override
220 {
221 // *** header ***
222 if (!header.read(connection)) {
223 return false;
224 }
225
226 // *** voltage ***
227 voltage = connection.expectFloat32();
228
229 // *** current ***
230 current = connection.expectFloat32();
231
232 // *** charge ***
233 charge = connection.expectFloat32();
234
235 // *** capacity ***
236 capacity = connection.expectFloat32();
237
238 // *** design_capacity ***
239 design_capacity = connection.expectFloat32();
240
241 // *** percentage ***
242 percentage = connection.expectFloat32();
243
244 // *** power_supply_status ***
245 power_supply_status = connection.expectInt8();
246
247 // *** power_supply_health ***
248 power_supply_health = connection.expectInt8();
249
250 // *** power_supply_technology ***
251 power_supply_technology = connection.expectInt8();
252
253 // *** present ***
254 if (!connection.expectBlock((char*)&present, 1)) {
255 return false;
256 }
257
258 // *** cell_voltage ***
259 int len = connection.expectInt32();
260 cell_voltage.resize(len);
261 if (len > 0 && !connection.expectBlock((char*)&cell_voltage[0], sizeof(yarp::conf::float32_t)*len)) {
262 return false;
263 }
264
265 // *** location ***
266 len = connection.expectInt32();
267 location.resize(len);
268 if (!connection.expectBlock((char*)location.c_str(), len)) {
269 return false;
270 }
271
272 // *** serial_number ***
273 len = connection.expectInt32();
274 serial_number.resize(len);
275 if (!connection.expectBlock((char*)serial_number.c_str(), len)) {
276 return false;
277 }
278
279 return !connection.isError();
280 }
281
282 bool readBottle(yarp::os::ConnectionReader& connection) override
283 {
284 connection.convertTextMode();
285 yarp::os::idl::WireReader reader(connection);
286 if (!reader.readListHeader(35)) {
287 return false;
288 }
289
290 // *** header ***
291 if (!header.read(connection)) {
292 return false;
293 }
294
295 // *** voltage ***
296 voltage = reader.expectFloat32();
297
298 // *** current ***
299 current = reader.expectFloat32();
300
301 // *** charge ***
302 charge = reader.expectFloat32();
303
304 // *** capacity ***
305 capacity = reader.expectFloat32();
306
307 // *** design_capacity ***
308 design_capacity = reader.expectFloat32();
309
310 // *** percentage ***
311 percentage = reader.expectFloat32();
312
313 // *** power_supply_status ***
314 power_supply_status = reader.expectInt8();
315
316 // *** power_supply_health ***
317 power_supply_health = reader.expectInt8();
318
319 // *** power_supply_technology ***
320 power_supply_technology = reader.expectInt8();
321
322 // *** present ***
323 present = reader.expectInt8();
324
325 // *** cell_voltage ***
326 if (connection.expectInt32() != (BOTTLE_TAG_LIST|BOTTLE_TAG_FLOAT32)) {
327 return false;
328 }
329 int len = connection.expectInt32();
330 cell_voltage.resize(len);
331 for (int i=0; i<len; i++) {
332 cell_voltage[i] = (yarp::conf::float32_t)connection.expectFloat32();
333 }
334
335 // *** location ***
336 if (!reader.readString(location)) {
337 return false;
338 }
339
340 // *** serial_number ***
341 if (!reader.readString(serial_number)) {
342 return false;
343 }
344
345 return !connection.isError();
346 }
347
349 bool read(yarp::os::ConnectionReader& connection) override
350 {
351 return (connection.isBareMode() ? readBare(connection)
352 : readBottle(connection));
353 }
354
355 bool writeBare(yarp::os::ConnectionWriter& connection) const override
356 {
357 // *** header ***
358 if (!header.write(connection)) {
359 return false;
360 }
361
362 // *** voltage ***
363 connection.appendFloat32(voltage);
364
365 // *** current ***
366 connection.appendFloat32(current);
367
368 // *** charge ***
369 connection.appendFloat32(charge);
370
371 // *** capacity ***
372 connection.appendFloat32(capacity);
373
374 // *** design_capacity ***
375 connection.appendFloat32(design_capacity);
376
377 // *** percentage ***
378 connection.appendFloat32(percentage);
379
380 // *** power_supply_status ***
381 connection.appendInt8(power_supply_status);
382
383 // *** power_supply_health ***
384 connection.appendInt8(power_supply_health);
385
386 // *** power_supply_technology ***
387 connection.appendInt8(power_supply_technology);
388
389 // *** present ***
390 connection.appendBlock((char*)&present, 1);
391
392 // *** cell_voltage ***
393 connection.appendInt32(cell_voltage.size());
394 if (cell_voltage.size()>0) {
395 connection.appendExternalBlock((char*)&cell_voltage[0], sizeof(yarp::conf::float32_t)*cell_voltage.size());
396 }
397
398 // *** location ***
399 connection.appendInt32(location.length());
400 connection.appendExternalBlock((char*)location.c_str(), location.length());
401
402 // *** serial_number ***
403 connection.appendInt32(serial_number.length());
404 connection.appendExternalBlock((char*)serial_number.c_str(), serial_number.length());
405
406 return !connection.isError();
407 }
408
409 bool writeBottle(yarp::os::ConnectionWriter& connection) const override
410 {
411 connection.appendInt32(BOTTLE_TAG_LIST);
412 connection.appendInt32(35);
413
414 // *** header ***
415 if (!header.write(connection)) {
416 return false;
417 }
418
419 // *** voltage ***
421 connection.appendFloat32(voltage);
422
423 // *** current ***
425 connection.appendFloat32(current);
426
427 // *** charge ***
429 connection.appendFloat32(charge);
430
431 // *** capacity ***
433 connection.appendFloat32(capacity);
434
435 // *** design_capacity ***
437 connection.appendFloat32(design_capacity);
438
439 // *** percentage ***
441 connection.appendFloat32(percentage);
442
443 // *** power_supply_status ***
444 connection.appendInt32(BOTTLE_TAG_INT8);
445 connection.appendInt8(power_supply_status);
446
447 // *** power_supply_health ***
448 connection.appendInt32(BOTTLE_TAG_INT8);
449 connection.appendInt8(power_supply_health);
450
451 // *** power_supply_technology ***
452 connection.appendInt32(BOTTLE_TAG_INT8);
453 connection.appendInt8(power_supply_technology);
454
455 // *** present ***
456 connection.appendInt32(BOTTLE_TAG_INT8);
457 connection.appendInt8(present);
458
459 // *** cell_voltage ***
461 connection.appendInt32(cell_voltage.size());
462 for (size_t i=0; i<cell_voltage.size(); i++) {
463 connection.appendFloat32(cell_voltage[i]);
464 }
465
466 // *** location ***
467 connection.appendInt32(BOTTLE_TAG_STRING);
468 connection.appendInt32(location.length());
469 connection.appendExternalBlock((char*)location.c_str(), location.length());
470
471 // *** serial_number ***
472 connection.appendInt32(BOTTLE_TAG_STRING);
473 connection.appendInt32(serial_number.length());
474 connection.appendExternalBlock((char*)serial_number.c_str(), serial_number.length());
475
476 connection.convertTextMode();
477 return !connection.isError();
478 }
479
481 bool write(yarp::os::ConnectionWriter& connection) const override
482 {
483 return (connection.isBareMode() ? writeBare(connection)
484 : writeBottle(connection));
485 }
486
487 // This class will serialize ROS style or YARP style depending on protocol.
488 // If you need to force a serialization style, use one of these classes:
491
492 // The name for this message, ROS will need this
493 static constexpr const char* typeName = "sensor_msgs/BatteryState";
494
495 // The checksum for this message, ROS will need this
496 static constexpr const char* typeChecksum = "476f837fa6771f6e16e3bf4ef96f8770";
497
498 // The source text for this message, ROS will need this
499 static constexpr const char* typeText = "\
500\n\
501# Constants are chosen to match the enums in the linux kernel\n\
502# defined in include/linux/power_supply.h as of version 3.7\n\
503# The one difference is for style reasons the constants are\n\
504# all uppercase not mixed case.\n\
505\n\
506# Power supply status constants\n\
507uint8 POWER_SUPPLY_STATUS_UNKNOWN = 0\n\
508uint8 POWER_SUPPLY_STATUS_CHARGING = 1\n\
509uint8 POWER_SUPPLY_STATUS_DISCHARGING = 2\n\
510uint8 POWER_SUPPLY_STATUS_NOT_CHARGING = 3\n\
511uint8 POWER_SUPPLY_STATUS_FULL = 4\n\
512\n\
513# Power supply health constants\n\
514uint8 POWER_SUPPLY_HEALTH_UNKNOWN = 0\n\
515uint8 POWER_SUPPLY_HEALTH_GOOD = 1\n\
516uint8 POWER_SUPPLY_HEALTH_OVERHEAT = 2\n\
517uint8 POWER_SUPPLY_HEALTH_DEAD = 3\n\
518uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4\n\
519uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5\n\
520uint8 POWER_SUPPLY_HEALTH_COLD = 6\n\
521uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7\n\
522uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8\n\
523\n\
524# Power supply technology (chemistry) constants\n\
525uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0\n\
526uint8 POWER_SUPPLY_TECHNOLOGY_NIMH = 1\n\
527uint8 POWER_SUPPLY_TECHNOLOGY_LION = 2\n\
528uint8 POWER_SUPPLY_TECHNOLOGY_LIPO = 3\n\
529uint8 POWER_SUPPLY_TECHNOLOGY_LIFE = 4\n\
530uint8 POWER_SUPPLY_TECHNOLOGY_NICD = 5\n\
531uint8 POWER_SUPPLY_TECHNOLOGY_LIMN = 6\n\
532\n\
533Header header\n\
534float32 voltage # Voltage in Volts (Mandatory)\n\
535float32 current # Negative when discharging (A) (If unmeasured NaN)\n\
536float32 charge # Current charge in Ah (If unmeasured NaN)\n\
537float32 capacity # Capacity in Ah (last full capacity) (If unmeasured NaN)\n\
538float32 design_capacity # Capacity in Ah (design capacity) (If unmeasured NaN)\n\
539float32 percentage # Charge percentage on 0 to 1 range (If unmeasured NaN)\n\
540uint8 power_supply_status # The charging status as reported. Values defined above\n\
541uint8 power_supply_health # The battery health metric. Values defined above\n\
542uint8 power_supply_technology # The battery chemistry. Values defined above\n\
543bool present # True if the battery is present\n\
544\n\
545float32[] cell_voltage # An array of individual cell voltages for each cell in the pack\n\
546 # If individual voltages unknown but number of cells known set each to NaN\n\
547string location # The location into which the battery is inserted. (slot number or plug)\n\
548string serial_number # The best approximation of the battery serial number\n\
549\n\
550================================================================================\n\
551MSG: std_msgs/Header\n\
552# Standard metadata for higher-level stamped data types.\n\
553# This is generally used to communicate timestamped data \n\
554# in a particular coordinate frame.\n\
555# \n\
556# sequence ID: consecutively increasing ID \n\
557uint32 seq\n\
558#Two-integer timestamp that is expressed as:\n\
559# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
560# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
561# time-handling sugar is provided by the client library\n\
562time stamp\n\
563#Frame this data is associated with\n\
564# 0: no frame\n\
565# 1: global frame\n\
566string frame_id\n\
567";
568
569 yarp::os::Type getType() const override
570 {
571 yarp::os::Type typ = yarp::os::Type::byName(typeName, typeName);
572 typ.addProperty("md5sum", yarp::os::Value(typeChecksum));
573 typ.addProperty("message_definition", yarp::os::Value(typeText));
574 return typ;
575 }
576};
577
578} // namespace sensor_msgs
579} // namespace rosmsg
580} // namespace yarp
581
582#endif // YARP_ROSMSG_sensor_msgs_BatteryState_h
#define BOTTLE_TAG_INT8
Definition: Bottle.h:19
#define BOTTLE_TAG_STRING
Definition: Bottle.h:26
#define BOTTLE_TAG_LIST
Definition: Bottle.h:28
#define BOTTLE_TAG_FLOAT32
Definition: Bottle.h:24
An interface for reading from a network connection.
virtual bool expectBlock(char *data, size_t len)=0
Read a block of data from the network connection.
virtual bool isBareMode() const =0
Check if the connection is bare mode.
virtual std::int32_t expectInt32()=0
Read a 32-bit integer from the network connection.
virtual bool convertTextMode()=0
Reads in a standard description in text mode, and converts it to a standard description in binary.
virtual yarp::conf::float32_t expectFloat32()=0
Read a 32-bit floating point number from the network connection.
virtual bool isError() const =0
virtual std::int8_t expectInt8()=0
Read a 8-bit integer from the network connection.
An interface for writing to a network connection.
virtual bool isError() const =0
virtual bool isBareMode() const =0
Check if the connection is bare mode.
virtual void appendInt8(std::int8_t data)=0
Send a representation of a 8-bit integer to the network connection.
virtual void appendFloat32(yarp::conf::float32_t data)=0
Send a representation of a 32-bit floating point number to the network connection.
virtual void appendExternalBlock(const char *data, size_t len)=0
Send a block of data to the network connection, without making a copy.
virtual bool convertTextMode()=0
Converts a standard description in binary into a textual description, if the connection is in text-mo...
virtual void appendInt32(std::int32_t data)=0
Send a representation of a 32-bit integer to the network connection.
virtual void appendBlock(const char *data, size_t len)=0
Send a block of data to the network connection.
static Type byName(const char *name)
Definition: Type.cpp:171
Type & addProperty(const char *key, const Value &val)
Definition: Type.cpp:134
A single value (typically within a Bottle).
Definition: Value.h:43
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
Definition: WirePortable.h:21
virtual bool read(yarp::os::idl::WireReader &reader)
virtual bool write(const yarp::os::idl::WireWriter &writer) const
IDL-friendly connection reader.
Definition: WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
Definition: WireReader.cpp:376
std::int8_t expectInt8()
Definition: WireReader.h:77
yarp::conf::float32_t expectFloat32()
Definition: WireReader.h:103
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
Definition: Header.h:159
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
Definition: Header.h:112
yarp::rosmsg::sensor_msgs::BatteryState BatteryState
Definition: BatteryState.h:21
float float32_t
Definition: numeric.h:76
bool read(ImageOf< PixelRgb > &dest, const std::string &src, image_fileformat format=FORMAT_ANY)
Definition: ImageFile.cpp:915
bool write(const ImageOf< PixelRgb > &src, const std::string &dest, image_fileformat format=FORMAT_PPM)
Definition: ImageFile.cpp:1091
The main, catch-all namespace for YARP.
Definition: dirs.h:16