nx_server_plugin_sdk 1.0 Server Plugin SDK

data.h
1 // Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/
2
3 #pragma once
4
5 #include <chrono>
6 #include <functional>
7 #include <limits>
8 #include <optional>
9 #include <string>
10 #include <vector>
11
12 #include <camera/camera_plugin.h>
13 #include <nx/kit/json.h>
14 #include <nx/sdk/cloud_storage/i_media_data_packet.h>
15 #include <nx/sdk/cloud_storage/i_integration.h>
16 #include <nx/sdk/i_device_info.h>
17
18 namespace nx::sdk::cloud_storage {
19
20 template<typename T>
21 class ValueOrError
22 {
23 public:
24 static ValueOrError<T> makeValue(T t)
25 {
26 ValueOrError<T> result;
27 result.v = std::move(t);
28 return result;
29 }
30
31 static ValueOrError<T> makeError(std::string s)
32 {
33 ValueOrError<T> result;
34 result.e = std::move(s);
35 return result;
36 }
37
38 operator bool() const
39 {
40 return (bool) v;
41 }
42
43 T value() const
44 {
45 return *v;
46 }
47
48 std::string error() const
49 {
50 return *e;
51 }
52
53 private:
54 std::optional<T> v;
55 std::optional<std::string> e;
56
57 ValueOrError() = default;
58 };
59
66 enum class SortOrder
67 {
68 ascending,
69 descending,
70 };
71
72 std::string sortOrderToString(SortOrder order);
73 SortOrder sortOrderFromString(const std::string& s);
74
75 struct IntegrationManifest
76 {
81 std::string id;
82
84 std::string name;
85
87 std::string description;
88
89 std::string version;
90 std::string vendor;
91
92 public:
93 IntegrationManifest(const char* jsonStr) noexcept(false);
94 IntegrationManifest(const nx::kit::Json& json) noexcept(false);
95 IntegrationManifest(
96 const std::string& id,
97 const std::string& name,
98 const std::string& description,
99 const std::string& version,
100 const std::string& vendor);
101
102 static ValueOrError<IntegrationManifest> fromJson(const char* jsonStr) noexcept;
103 static ValueOrError<IntegrationManifest> fromJson(const nx::kit::Json& json) noexcept;
104
105 IntegrationManifest() = default;
106
107 template<typename T>
108 IntegrationManifest(const T&) = delete;
109
110 bool operator==(const IntegrationManifest&) const;
111
112 nx::kit::Json to_json() const;
113 };
114
115 struct TimePeriod
116 {
117 std::chrono::milliseconds startTimestamp{-1};
118 std::chrono::milliseconds duration{-1};
119
120 public:
121 TimePeriod(const char* jsonStr) noexcept(false);
122 TimePeriod(const nx::kit::Json& json) noexcept(false);
123 TimePeriod(std::chrono::milliseconds startTimestamp, std::chrono::milliseconds duration);
124 TimePeriod() = default;
125
126 static ValueOrError<TimePeriod> fromJson(const char* jsonStr) noexcept;
127 static ValueOrError<TimePeriod> fromJson(const nx::kit::Json& json) noexcept;
128
129 template<typename T>
130 TimePeriod(const T&) = delete;
131
132 bool isInfinite() const;
133 bool contains(std::chrono::milliseconds timestamp) const;
134 bool isNull() const;
135 bool intersects(const TimePeriod& other) const;
136 std::optional<std::chrono::milliseconds> endTimestamp() const;
137
138 nx::kit::Json to_json() const;
139 bool operator<(const TimePeriod& other) const;
140 bool operator==(const TimePeriod& other) const;
141 bool operator!=(const TimePeriod& other) const;
142 };
143
144 class TimePeriodList
145 {
146 public:
147 TimePeriodList(const char* jsonStr) noexcept(false);
148 TimePeriodList(const nx::kit::Json& json) noexcept(false);
149 TimePeriodList() = default;
150
151 static ValueOrError<TimePeriodList> fromJson(const char* jsonStr) noexcept;
152 static ValueOrError<TimePeriodList> fromJson(const nx::kit::Json& json) noexcept;
153
154 TimePeriodList(SortOrder order);
155
156 template<typename T>
157 TimePeriodList(const T&) = delete;
158
159 void forEach(std::function<void(const TimePeriod&)> func) const;
160 nx::kit::Json to_json() const;
161 void reverse();
162 void shrink(size_t size);
163 void append(const TimePeriod& period);
164 void setLastDuration(std::chrono::milliseconds duration);
165
166 SortOrder sortOrder() const;
167 size_t size() const;
168 bool empty() const;
169 std::optional<TimePeriod> last() const;
170
171 private:
172 SortOrder m_order = SortOrder::ascending;
173 std::vector<int64_t> m_periods;
174 std::optional<std::chrono::milliseconds> m_lastStartTimestmapMs;
175
176 private:
177 void recalculateLastTimestamp();
178 };
179
180 struct KeyValuePair
181 {
182 std::string name;
183 std::string value;
184
185 public:
186 KeyValuePair(const char* jsonStr) noexcept(false);
187 KeyValuePair(const nx::kit::Json& json) noexcept(false);
188 KeyValuePair() = default;
189 KeyValuePair(const std::string& name, const std::string& value);
190
191 static ValueOrError<KeyValuePair> fromJson(const char* jsonStr) noexcept;
192 static ValueOrError<KeyValuePair> fromJson(const nx::kit::Json& json) noexcept;
193
194 template<typename T>
195 KeyValuePair(const T&) = delete;
196
197 bool operator==(const KeyValuePair&) const;
198
199 nx::kit::Json to_json() const;
200 };
201
202 nx::kit::Json keyValuePairsToJson(const std::vector<KeyValuePair>& keyValuePairList);
203
204 using DeviceParameter = KeyValuePair;
205
209 struct DeviceDescription
210 {
211 std::vector<DeviceParameter> parameters;
212
213 public:
214 DeviceDescription() = default;
215 DeviceDescription(const char* jsonData) noexcept(false);
216 DeviceDescription(const nx::kit::Json& json) noexcept(false);
217 DeviceDescription(const nx::sdk::IDeviceInfo* info);
218
219 static ValueOrError<DeviceDescription> fromJson(const char* jsonStr) noexcept;
220 static ValueOrError<DeviceDescription> fromJson(const nx::kit::Json& json) noexcept;
221
222 template<typename T>
223 DeviceDescription(const T&) = delete;
224
225 bool operator==(const DeviceDescription&) const;
226
227 const char* getParamValue(const std::string& key) const;
228 nx::kit::Json to_json() const;
229 std::optional<std::string> deviceId() const;
230 };
231
232 std::string deviceId(nx::sdk::cloud_storage::IDeviceAgent* deviceAgent);
233
234 int toStreamIndex(nxcip::MediaStreamQuality quality);
235
236 std::string toString(sdk::cloud_storage::MetadataType metadataType);
237
243 struct Bookmark
244 {
246 std::string id;
247
249 std::string creatorId;
250
251 std::chrono::milliseconds creationTimestamp{};
252 std::string name;
253 std::string description;
254 std::chrono::milliseconds timeout = std::chrono::milliseconds(-1);
255 std::chrono::milliseconds startTimestamp{};
256 std::chrono::milliseconds duration{};
257 std::vector<std::string> tags;
258 std::string deviceId;
259
260 public:
261 Bookmark(const char* jsonData) noexcept(false);
262 Bookmark(const nx::kit::Json& json) noexcept(false);
263 Bookmark() = default;
264
265 static ValueOrError<Bookmark> fromJson(const char* jsonStr) noexcept;
266 static ValueOrError<Bookmark> fromJson(const nx::kit::Json& json) noexcept;
267
268 template<typename T>
269 Bookmark(const T&) = delete;
270
271 bool operator==(const Bookmark&) const;
272
273 nx::kit::Json to_json() const;
274 };
275
276 using BookmarkList = std::vector<Bookmark>;
277
278 BookmarkList bookmarkListFromJson(const char* data);
279
284 struct BookmarkFilter
285 {
286 enum class SortColumn
287 {
288 name,
289 startTime,
290 duration,
291 creationTime,
292 tags,
293 description,
294 };
295
296 std::optional<std::string> id;
297 std::optional<std::chrono::milliseconds> startTimestamp;
298 std::optional<std::chrono::milliseconds> endTimestamp;
299
301 std::optional<std::string> text;
302
303 std::optional<int> limit;
304 SortOrder order = SortOrder::ascending;
305 SortColumn column = SortColumn::startTime;
306
308 std::optional<std::chrono::milliseconds> minVisibleLength;
309
310 std::vector<std::string> deviceIds;
311 std::optional<std::chrono::milliseconds> creationStartTimestamp;
312 std::optional<std::chrono::milliseconds> creationEndTimestamp;
313
314 public:
315 BookmarkFilter(const char* urlParams) noexcept(false);
316 BookmarkFilter(const nx::kit::Json& json) noexcept(false);
317 BookmarkFilter() = default;
318
319 static ValueOrError<BookmarkFilter> fromUrlParams(const char* urlParams) noexcept;
320 static ValueOrError<BookmarkFilter> fromJson(const nx::kit::Json& json) noexcept;
321
322 template<typename T>
323 BookmarkFilter(const T&) = delete;
324
325 bool operator==(const BookmarkFilter&) const;
326
327 nx::kit::Json to_json() const;
328 std::string toUrlParams() const;
329
330 static std::string sortColumnToString(SortColumn column);
331 static SortColumn sortColumnFromString(const std::string& s);
332 };
333
339 struct Motion
340 {
341 int channel = 0;
342 std::chrono::milliseconds startTimestamp;
343 std::chrono::milliseconds duration{};
344 std::string deviceId;
345
354 std::string dataBase64;
355
356 public:
357 Motion() = default;
358 Motion(const char* jsonData) noexcept(false);
359 Motion(const nx::kit::Json& json) noexcept(false);
360
361 static ValueOrError<Motion> fromJson(const char* jsonStr) noexcept;
362 static ValueOrError<Motion> fromJson(const nx::kit::Json& json) noexcept;
363
364 template<typename T>
365 Motion(const T&) = delete;
366
367 bool operator==(const Motion&) const;
368
369 nx::kit::Json to_json() const;
370 };
371
372 struct Rect
373 {
374 double x = 0;
375 double y = 0;
376 double w = 0;
377 double h = 0;
378
379 public:
380 Rect(const char* jsonData) noexcept(false);
381 Rect(const nx::kit::Json& json) noexcept(false);
382 Rect(double x, double y, double w, double h);
383 Rect() = default;
384
385 static ValueOrError<Rect> fromJson(const char* jsonStr) noexcept;
386 static ValueOrError<Rect> fromJson(const nx::kit::Json& json) noexcept;
387
388 template<typename T>
389 Rect(const T&) = delete;
390
391 bool operator==(const Rect&) const;
392
393 nx::kit::Json to_json() const;
394
395 bool isEmpty() const;
396 bool intersectsWith(const Rect& other) const;
397 double left() const;
398 double top() const;
399 double right() const;
400 double bottom() const;
401
402 private:
403 bool isInside(double x, double y) const;
404 };
405
410 struct MotionFilter
411 {
412 std::vector<std::string> deviceIds;
413 TimePeriod timePeriod;
414
421 std::vector<Rect> regions;
422
424 std::optional<int> limit;
425
427 SortOrder order = SortOrder::ascending;
428
433 std::chrono::milliseconds detailLevel;
434
435 public:
436 MotionFilter() = default;
437 MotionFilter(const char* jsonData) noexcept(false);
438 MotionFilter(const nx::kit::Json& json) noexcept(false);
439
440 static ValueOrError<MotionFilter> fromJson(const char* jsonStr) noexcept;
441 static ValueOrError<MotionFilter> fromJson(const nx::kit::Json& json) noexcept;
442
443 template<typename T>
444 MotionFilter(const T&) = delete;
445
446 bool operator==(const MotionFilter&) const;
447
448 nx::kit::Json to_json() const;
449 };
450
451 using Attribute = KeyValuePair;
452 using Attributes = std::vector<KeyValuePair>;
453
454 struct ObjectRegion
455 {
457 std::string boundingBoxGridBase64;
458
459 public:
460 ObjectRegion() = default;
461 ObjectRegion(const nx::kit::Json & json) noexcept(false);
462 ObjectRegion(const char* jsonData) noexcept(false);
463
464 static ValueOrError<ObjectRegion> fromJson(const char* jsonStr) noexcept;
465 static ValueOrError<ObjectRegion> fromJson(const nx::kit::Json& json) noexcept;
466
467 template<typename T>
468 ObjectRegion(const T&) = delete;
469
470 bool operator==(const ObjectRegion&) const;
471
472 nx::kit::Json to_json() const;
473 };
474
475 std::string trackImageTypeToString(TrackImageType type);
476 TrackImageType trackImageTypeFromString(const std::string& s);
477
481 struct Image
482 {
483 std::string objectTrackId;
484
486 std::string format;
487
489 std::string data64;
490
491 public:
492 Image() = default;
493 Image(const nx::kit::Json& json) noexcept(false);
494 Image(const char* jsonData) noexcept(false);
495
496 static ValueOrError<Image> fromJson(const char* jsonStr) noexcept;
497 static ValueOrError<Image> fromJson(const nx::kit::Json& json) noexcept;
498
499 template<typename T>
500 Image(const T&) = delete;
501
502 nx::kit::Json to_json() const;
503
504 bool operator==(const Image&) const;
505 };
506
510 struct BaseImage
511 {
512 std::chrono::microseconds timestamp{};
513 Rect rect;
514 int streamIndex = -1;
515 std::optional<Image> image;
516
517 public:
518 BaseImage() = default;
519 BaseImage(const nx::kit::Json& json) noexcept(false);
520 BaseImage(const char* jsonData) noexcept(false);
521
522 bool operator==(const BaseImage&) const;
523
524 template<typename T>
525 BaseImage(const T&) = delete;
526
527 nx::kit::Json to_json() const;
528 std::map<std::string, nx::kit::detail::json11::Json> toBaseObject() const;
529
530 bool isNull() const;
531 };
532
533 struct BestShot: public BaseImage
534 {
535 BestShot() = default;
536 BestShot(const nx::kit::Json& json) noexcept(false);
537 BestShot(const BaseImage& data) : BaseImage(data) {}
538 BestShot(const char* jsonStr) noexcept(false);
539
540 bool operator==(const BestShot&) const;
541
542 static ValueOrError<BestShot> fromJson(const char* jsonStr) noexcept;
543 static ValueOrError<BestShot> fromJson(const nx::kit::Json& json) noexcept;
544
545 nx::kit::Json to_json() const;
546 };
547
548 struct Title: public BaseImage
549 {
551 std::string text;
552
553 public:
554 Title() = default;
555 Title(const nx::kit::Json& json) noexcept(false);
556 Title(const BaseImage& data): BaseImage(data) {}
557 Title(const char* jsonStr) noexcept(false);
558
559 bool operator==(const Title&) const;
560
561 static ValueOrError<Title> fromJson(const char* jsonStr) noexcept;
562 static ValueOrError<Title> fromJson(const nx::kit::Json& json) noexcept;
563
564 nx::kit::Json to_json() const;
565 };
566
567 using TrackImage = BaseImage;
568
569 struct ObjectTrack
570 {
571 std::string id;
572
574 std::string deviceId;
575
581 std::string objectTypeId;
582
588 Attributes attributes;
589
591 std::chrono::microseconds firstAppearanceTimestamp{};
592
594 std::chrono::microseconds lastAppearanceTimestamp{};
595
597 ObjectRegion objectPosition;
598
600 std::string analyticsEngineId;
601
602 std::optional<BestShot> bestShot;
603 std::optional<Title> title;
604
605 public:
606 ObjectTrack() = default;
607 ObjectTrack(const nx::kit::Json & json) noexcept(false);
608 ObjectTrack(const char* jsonData) noexcept(false);
609
610 static ValueOrError<ObjectTrack> fromJson(const char* jsonStr) noexcept;
611 static ValueOrError<ObjectTrack> fromJson(const nx::kit::Json& json) noexcept;
612
613 template<typename T>
614 ObjectTrack(const T&) = delete;
615
616 bool operator==(const ObjectTrack&) const;
617
618 nx::kit::Json to_json() const;
619 };
620
621 using AnalyticsLookupResult = std::vector<ObjectTrack>;
622
623 AnalyticsLookupResult analyticsLookupResultFromJson(const char* data);
624
628 struct RangePoint
629 {
630 RangePoint() = default;
631 RangePoint(const nx::kit::Json& json) noexcept(false);
632 RangePoint(const char* jsonData) noexcept(false);
633
634 static ValueOrError<RangePoint> fromJson(const char* jsonStr) noexcept;
635 static ValueOrError<RangePoint> fromJson(const nx::kit::Json& json) noexcept;
636
637 template<typename T>
638 RangePoint(const T&) = delete;
639
640 RangePoint(float value, bool inclusive);
641
642 bool operator==(const RangePoint&) const;
643
644 nx::kit::Json to_json() const;
645
646 float value = 0.0;
647 bool inclusive = false;
648 };
649
654 struct NumericRange
655 {
656 std::optional<RangePoint> from;
657 std::optional<RangePoint> to;
658
659 public:
660 NumericRange() = default;
661 NumericRange(const nx::kit::Json& json) noexcept(false);
662 NumericRange(const char* jsonData) noexcept(false);
663
664 static ValueOrError<NumericRange> fromJson(const char* jsonStr) noexcept;
665 static ValueOrError<NumericRange> fromJson(const nx::kit::Json& json) noexcept;
666
667 template<typename T>
668 NumericRange(const T&) = delete;
669
670 bool operator==(const NumericRange&) const;
671
672 NumericRange(float value): from(RangePoint{value, true}), to(RangePoint{value, true}) {}
673
674 NumericRange(std::optional<RangePoint> from, std::optional<RangePoint> to):
675 from(std::move(from)), to(std::move(to))
676 {
677 }
678
679 static std::optional<NumericRange> fromString(const std::string& s);
680
681 nx::kit::Json to_json() const;
682
683 bool intersects(const NumericRange& range) const;
684 bool hasRange(const NumericRange& range) const;
685 };
686
695 struct AttributeSearchCondition
696 {
712 enum class Type
713 {
714 attributePresenceCheck,
715 attributeValueMatch,
716 textMatch,
717 numericRangeMatch,
718 };
719
720 Type type;
721 std::string name;
722 std::string value;
723 std::string text;
724
729 bool isNegative = false;
730
732 bool matchesFromStart = false;
733
735 bool matchesTillEnd = false;
736
742 NumericRange range;
743
744 public:
745 AttributeSearchCondition() = default;
746 AttributeSearchCondition(const nx::kit::Json& json) noexcept(false);
747 AttributeSearchCondition(const char* jsonData) noexcept(false);
748
749 static ValueOrError<AttributeSearchCondition> fromJson(const char* jsonStr) noexcept;
750 static ValueOrError<AttributeSearchCondition> fromJson(const nx::kit::Json& json) noexcept;
751
752 template<typename T>
753 AttributeSearchCondition(const T&) = delete;
754
755 bool operator==(const AttributeSearchCondition&) const;
756
757 nx::kit::Json to_json() const;
758
759 static std::string typeToString(Type type);
760 static Type typeFromString(const std::string& s);
761 };
762
766 struct AnalyticsFilter
767 {
768 enum Option
769 {
770 none = 0x0,
771 ignoreTextFilter = 0x1,
772 ignoreBoundingBox = 0x2,
773 ignoreTimePeriod = 0x4,
774 };
775
777 std::vector<std::string> deviceIds;
778
783 std::vector<std::string> objectTypeIds;
784
786 std::optional<std::string> objectTrackId;
787
792 TimePeriod timePeriod;
793
795 std::optional<Rect> boundingBox;
796
797 std::optional<int> maxObjectTracksToSelect;
798 std::vector<AttributeSearchCondition> attributeSearchConditions;
799
801 SortOrder order = SortOrder::descending;
802
803 std::optional<std::string> analyticsEngineId;
804 int options = Option::none;
805 std::chrono::milliseconds detailLevel{};
806
807 public:
808 AnalyticsFilter() = default;
809 AnalyticsFilter(const char* jsonData) noexcept(false);
810 AnalyticsFilter(const nx::kit::Json& json) noexcept(false);
811
812 static ValueOrError<AnalyticsFilter> fromJson(const char* jsonStr) noexcept;
813 static ValueOrError<AnalyticsFilter> fromJson(const nx::kit::Json& json) noexcept;
814
815 template<typename T>
816 AnalyticsFilter(const T&) = delete;
817
818 bool operator==(const AnalyticsFilter&) const;
819
820 nx::kit::Json to_json() const;
821
822 static std::string optionsToString(int options);
823 static int optionsFromString(const std::string& s);
824 };
825
826 struct CodecInfoData
827 {
828 nxcip::CompressionType compressionType = nxcip::CompressionType::AV_CODEC_ID_NONE;
829 nxcip::PixelFormat pixelFormat = nxcip::PixelFormat::AV_PIX_FMT_YUV420P;
830 nxcip::MediaType mediaType = nxcip::MediaType::AVMEDIA_TYPE_UNKNOWN;
831 int width = -1;
832 int height = -1;
833 int64_t codecTag = -1;
834 int64_t bitRate = -1;
835 int channels = -1;
836 int frameSize = -1;
837 int blockAlign = -1;
838 int sampleRate = -1;
839 nxcip::SampleFormat sampleFormat = nxcip::SampleFormat::AV_SAMPLE_FMT_NONE;
840 int bitsPerCodedSample = -1;
841 int64_t channelLayout = -1;
842 std::string extradataBase64;
843 int channelNumber = -1;
844
845 public:
846 CodecInfoData();
847 CodecInfoData(const char* jsonData) noexcept(false);
848 CodecInfoData(const nx::kit::Json& json) noexcept(false);
849 CodecInfoData(const nx::sdk::cloud_storage::ICodecInfo* codecInfo);
850
851 static ValueOrError<CodecInfoData> fromJson(const char* jsonStr) noexcept;
852 static ValueOrError<CodecInfoData> fromJson(const nx::kit::Json& json) noexcept;
853
854 template<typename T>
855 CodecInfoData(const T&) = delete;
856
857 bool operator==(const CodecInfoData&) const;
858
859 nx::kit::Json to_json() const;
860 };
861
862 IDeviceInfo* deviceInfo(const DeviceDescription& deviceDescription);
863
864 class MediaPacket;
865
866 struct MediaPacketData
867 {
868 std::vector<uint8_t> data;
869 int dataSize = 0;
870 nxcip::CompressionType compressionType = nxcip::CompressionType::AV_CODEC_ID_NONE;
871 nxcip::UsecUTCTimestamp timestampUs = 0;
872 IMediaDataPacket::Type type = IMediaDataPacket::Type::unknown;
873 int channelNumber = -1;
874 bool isKeyFrame = false;
875 std::vector<uint8_t> encryptionData;
876
877 public:
878 MediaPacketData(const IMediaDataPacket* mediaPacket, std::chrono::milliseconds startTime);
879 MediaPacketData() = default;
880 };
881
882 struct CloudDeviceReportEntry
883 {
884 std::string id;
885 std::string serviceId;
886
887 public:
888 CloudDeviceReportEntry() = default;
889 CloudDeviceReportEntry(const char* jsonData) noexcept(false);
890 CloudDeviceReportEntry(const nx::kit::Json& json) noexcept(false);
891
892 static ValueOrError<CloudDeviceReportEntry> fromJson(const char* jsonStr) noexcept;
893 static ValueOrError<CloudDeviceReportEntry> fromJson(const nx::kit::Json& json) noexcept;
894
895 bool operator==(const CloudDeviceReportEntry& other) const;
896 nx::kit::Json to_json() const;
897 };
898
899 using CloudDeviceEntryList = std::vector<CloudDeviceReportEntry>;
900
901 struct CloudDeviceReport
902 {
903 std::string cloudSystemId;
904 CloudDeviceEntryList devices;
905
906 public:
907 CloudDeviceReport() = default;
908 CloudDeviceReport(const char* jsonData) noexcept(false);
909 CloudDeviceReport(const nx::kit::Json& json) noexcept(false);
910
911 static ValueOrError<CloudDeviceReport> fromJson(const char* jsonStr) noexcept;
912 static ValueOrError<CloudDeviceReport> fromJson(const nx::kit::Json& json) noexcept;
913
914 bool operator==(const CloudDeviceReport& other) const;
915 nx::kit::Json to_json() const;
916 };
917
918 } // nx::sdk::namespace cloud_storage
nx::sdk::cloud_storage::RangePoint
Definition: data.h:628
nx::sdk::cloud_storage::ICodecInfo
Definition: i_codec_info.h:15
nx::sdk::cloud_storage::Motion
Definition: data.h:339
nx::sdk::cloud_storage::Title::text
std::string text
Definition: data.h:551
nx::sdk::cloud_storage::KeyValuePair
Definition: data.h:180
nx::sdk::cloud_storage::TimePeriodList
Definition: data.h:144
nx::sdk::cloud_storage::MotionFilter::regions
std::vector< Rect > regions
Definition: data.h:421
nx::sdk::cloud_storage::ObjectRegion::boundingBoxGridBase64
std::string boundingBoxGridBase64
Definition: data.h:457
nx::sdk::cloud_storage::IMediaDataPacket
Definition: i_media_data_packet.h:17
nx::sdk::cloud_storage::Bookmark::id
std::string id
Definition: data.h:246
nx::sdk::cloud_storage::ObjectTrack::objectTypeId
std::string objectTypeId
Definition: data.h:581
nx::kit::detail::json11::Json
Definition: json.cpp:80
nx::sdk::cloud_storage::AttributeSearchCondition
Definition: data.h:695
nx::sdk::cloud_storage::ObjectTrack::firstAppearanceTimestamp
std::chrono::microseconds firstAppearanceTimestamp
Definition: data.h:591
nx::sdk::cloud_storage::ValueOrError
Definition: data.h:21
nx::sdk::cloud_storage::ObjectTrack::objectPosition
ObjectRegion objectPosition
Definition: data.h:597
nx::sdk::cloud_storage::ObjectTrack::attributes
Attributes attributes
Definition: data.h:588
nx::sdk::cloud_storage::MediaPacketData
Definition: data.h:866
nx::sdk::cloud_storage::Bookmark
Definition: data.h:243
nxcip::MediaType
MediaType
Definition: camera_plugin_types.h:65
nx::sdk::cloud_storage::MotionFilter::order
SortOrder order
Definition: data.h:427
nx::sdk::cloud_storage::CodecInfoData
Definition: data.h:826
json.h
nx::sdk::cloud_storage::IntegrationManifest::name
std::string name
Definition: data.h:84
nx::sdk::cloud_storage::AnalyticsFilter::timePeriod
TimePeriod timePeriod
Definition: data.h:792
nx::sdk::cloud_storage::TimePeriod
Definition: data.h:115
nx::sdk::cloud_storage::AnalyticsFilter::objectTrackId
std::optional< std::string > objectTrackId
Definition: data.h:786
nx::sdk::cloud_storage::CloudDeviceReportEntry
Definition: data.h:882
nx::sdk::cloud_storage::ObjectTrack::lastAppearanceTimestamp
std::chrono::microseconds lastAppearanceTimestamp
Definition: data.h:594
nx::sdk::cloud_storage::ObjectRegion
Definition: data.h:454
nx::sdk::cloud_storage::MotionFilter::detailLevel
std::chrono::milliseconds detailLevel
Definition: data.h:433
nx::sdk::cloud_storage::Title
Definition: data.h:548
nx::sdk::cloud_storage::ObjectTrack::deviceId
std::string deviceId
Definition: data.h:574
nx::sdk::cloud_storage::AttributeSearchCondition::range
NumericRange range
Definition: data.h:742
nx::sdk::IDeviceInfo
Definition: i_device_info.h:13
nx::sdk::cloud_storage::Image
Definition: data.h:481
nx::sdk::cloud_storage::ObjectTrack
Definition: data.h:569
nx::sdk::cloud_storage::IDeviceAgent
Definition: i_device_agent.h:21
nx::sdk::cloud_storage::MotionFilter::limit
std::optional< int > limit
Definition: data.h:424
nx::sdk::cloud_storage::AnalyticsFilter::order
SortOrder order
Definition: data.h:801
nx::sdk::cloud_storage::AttributeSearchCondition::matchesFromStart
bool matchesFromStart
Definition: data.h:732
nx::sdk::cloud_storage::BookmarkFilter::text
std::optional< std::string > text
Definition: data.h:301
nx::sdk::cloud_storage::ObjectTrack::analyticsEngineId
std::string analyticsEngineId
Definition: data.h:600
nx::sdk::cloud_storage::AttributeSearchCondition::Type
Type
Definition: data.h:712
nx::sdk::cloud_storage::AttributeSearchCondition::matchesTillEnd
bool matchesTillEnd
Definition: data.h:735
nx::sdk::cloud_storage::MotionFilter
Definition: data.h:410
nx::sdk::cloud_storage::AnalyticsFilter::deviceIds
std::vector< std::string > deviceIds
Definition: data.h:777
nx::sdk::cloud_storage::AttributeSearchCondition::isNegative
bool isNegative
Definition: data.h:729
nx::sdk::cloud_storage::Image::data64
std::string data64
Definition: data.h:489
nx::sdk::cloud_storage::AnalyticsFilter
Definition: data.h:766
nx::sdk::cloud_storage::DeviceDescription
Definition: data.h:209
nx::sdk::cloud_storage::Image::format
std::string format
Definition: data.h:486
nx::sdk::cloud_storage::BookmarkFilter
Definition: data.h:284
nx::sdk::cloud_storage::NumericRange
Definition: data.h:654
nx::sdk::cloud_storage::IntegrationManifest::id
std::string id
Definition: data.h:81
nx::sdk::cloud_storage::BaseImage
Definition: data.h:510
nx::sdk::cloud_storage::Rect
Definition: data.h:372
nx::sdk::cloud_storage
Definition: algorithm.cpp:9
nx::sdk::cloud_storage::CloudDeviceReport
Definition: data.h:901
nx::sdk::cloud_storage::IntegrationManifest
Definition: data.h:75
nx::sdk::cloud_storage::IntegrationManifest::description
std::string description
Definition: data.h:87
nx::sdk::cloud_storage::BookmarkFilter::minVisibleLength
std::optional< std::chrono::milliseconds > minVisibleLength
Definition: data.h:308
nx::sdk::cloud_storage::AnalyticsFilter::objectTypeIds
std::vector< std::string > objectTypeIds
Definition: data.h:783
nxcip::PixelFormat
PixelFormat
Definition: camera_plugin_types.h:39
nxcip::MediaStreamQuality
MediaStreamQuality
Definition: camera_plugin.h:1189
nxcip::SampleFormat
SampleFormat
Definition: camera_plugin_types.h:76
nx::sdk::cloud_storage::AnalyticsFilter::boundingBox
std::optional< Rect > boundingBox
Definition: data.h:795
nx::sdk::cloud_storage::BestShot
Definition: data.h:533
nx::sdk::cloud_storage::Motion::dataBase64
std::string dataBase64
Definition: data.h:354
nx::sdk::cloud_storage::Bookmark::creatorId
std::string creatorId
Definition: data.h:249