CVB++ 15.0
Loading...
Searching...
No Matches
classifier.hpp
1#pragma once
2
3#include "../_cexports/c_minos.h"
4
5#include "../global.hpp"
6#include "../rect.hpp"
7#include "../string.hpp"
8#include "../point_2d.hpp"
9#include "../matrix_2d.hpp"
10#include "../image.hpp"
11
12#include "learn_parameters.hpp"
13#include "search_result.hpp"
14
15#include <sstream>
16#include <iomanip>
17#include <ctime>
18#include <chrono>
19#include <vector>
20#include <memory>
21#include <utility>
22#include <cstdint>
23
24namespace Cvb
25{
26 CVB_BEGIN_INLINE_NS
27
28 namespace Minos
29 {
30 class Classifier;
31 }
32
33 template <>
34 inline HandleGuard<Minos::Classifier>::HandleGuard(void *handle) noexcept
35 : HandleGuard<Minos::Classifier>(handle, [](void *h) { CVB_CALL_CAPI(ReleaseObject(h)); })
36 {
37 }
38
40
47 namespace Minos
48 {
49
51 enum class QualityFeedback
52 {
54 Unnormalized = CExports::Quality_Unnormalized,
56 Normalized = CExports::Quality_ReturnCorrelation
57 };
58
69
78
80
83 {
84 public:
86
91 ClassifierModelInfo(const String &name, Point2D<int> advanceVector)
92 : name_(name)
93 , advanceVector_(advanceVector)
94 {
95 }
96
98
102 String Name() const
103 {
104 return name_;
105 }
106
108
112 void SetName(const String &name)
113 {
114 name_ = name;
115 }
116
118
123 {
124 return advanceVector_;
125 }
126
128
132 void SetAdvanceVector(Point2D<int> advanceVector)
133 {
134 advanceVector_ = advanceVector;
135 }
136
137 private:
138 String name_;
139 Point2D<int> advanceVector_;
140 }; /* class ClassifierModelInfo */
141
143
150 inline bool operator!=(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept
151 {
152 return (lhs.Name() != rhs.Name()) || (lhs.AdvanceVector() != rhs.AdvanceVector());
153 }
154
156
163 inline bool operator==(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept
164 {
165 return (!(lhs != rhs));
166 }
167
169
171 class ClassifierModelInfoCollection
172 {
173 public:
174 explicit ClassifierModelInfoCollection(const SharedHandleGuard<Classifier> &sguard)
175 : shandle_(sguard)
176 {
177 }
178
179 ClassifierModelInfoCollection(const ClassifierModelInfoCollection &other) noexcept = default;
180 ClassifierModelInfoCollection &operator=(const ClassifierModelInfoCollection &other) noexcept = default;
181 ClassifierModelInfoCollection(ClassifierModelInfoCollection &&other) noexcept = default;
182 ClassifierModelInfoCollection &operator=(ClassifierModelInfoCollection &&other) noexcept = default;
183 ~ClassifierModelInfoCollection() = default;
184
186
191 int Count() const
192 {
193 return static_cast<int>(CVB_CALL_CAPI(NumCLFModels(shandle_.Handle())));
194 }
195
197
204 {
205 Char *pstr = nullptr;
206 CExports::cvbdim_t advX = 0, advY = 0;
207 CVB_CALL_CAPI_CHECKED(GetCLFModelDataTyped(shandle_.Handle(), index, pstr, advX, advY));
208
209 return ClassifierModelInfo(pstr != nullptr ? String(pstr) : String(),
210 Point2D<int>(static_cast<int>(advX), static_cast<int>(advY)));
211 }
212
214
220 void WriteInfo(int index, ClassifierModelInfo model)
221 {
222 if (model == ReadInfo(index))
223 {
224 return;
225 }
226 CVB_CALL_CAPI_CHECKED(SetCLFModelDataTyped(shandle_.Handle(), index, model.Name().c_str(),
227 model.AdvanceVector().X(), model.AdvanceVector().Y()));
228 }
229
231
237 {
238 auto count = Count();
240 for (decltype(count) i = 0; i < count; ++i)
241 {
242 info.push_back(ReadInfo(i));
243 }
244
245 return info;
246 }
247
248 private:
249 SharedHandleGuard<Classifier> shandle_;
250 }; /* class ClassifierModelInfoCollection */
251
253
255 class Classifier
256 {
257 private:
258 // Internal helper constructor version
259 explicit Classifier(HandleGuard<Classifier> &&guard, const String &srcFileName = String())
260 : shandle_(std::move(guard))
261 , fileName_(srcFileName)
262 , models_(shandle_)
263 {
264 // Parse creation date (this property is immutable, so we might as well just parse it once)
265 auto strDate = CVB_CALL_CAPI(CLFCreationDate(shandle_.Handle()));
266 if (strDate)
267 {
268 std::istringstream iss(strDate);
269 std::tm tm = {};
270 // iss.imbue (std::locale ("en-US"));
271 // iss >> std::get_time (&tm, "%m/%d/%Y %I:%M:%S %p");
272 iss >> std::get_time(&tm, "%d.%m.%y %H:%M:%S");
273 if (iss.fail())
274 {
275 creationDate_ = std::chrono::system_clock::now();
276 }
277 else
278 {
280 }
281 }
282 else
283 {
284 creationDate_ = std::chrono::system_clock::now();
285 }
286
287 // Determine classifier extent
288 CExports::cvbdim_t left = 0, top = 0, right = 0, bottom = 0;
289 CVB_CALL_CAPI_CHECKED(GetCLFExtent(shandle_.Handle(), left, top, right, bottom));
290 clfExtent_ =
291 Rect<int>(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right), static_cast<int>(bottom));
292 }
293
294 // Internal helper
295 static CExports::cvbval_t MaxSearch() noexcept
296 {
297 return 32767;
298 }
299
300 public:
302
306 explicit Classifier(const String &fileName)
307 : Classifier(std::move(*Load(fileName)))
308 {
309 }
310
311 Classifier(const Classifier &other) = delete;
312 Classifier &operator=(const Classifier &other) = delete;
313 Classifier(Classifier &&other) noexcept = default;
314 Classifier &operator=(Classifier &&other) noexcept = default;
315 virtual ~Classifier() = default;
316
317 public:
319
325 {
326 CExports::CLF clf = nullptr;
327 CVB_CALL_CAPI_CHECKED(LoadCLFFileTyped(fileName.c_str(), clf));
328 return std::unique_ptr<Classifier>(new Classifier(HandleGuard<Classifier>(clf), fileName));
329 }
330
332
338 static std::unique_ptr<Classifier> FromBuffer(const void *buffer, size_t size)
339 {
340 return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
341 /* Note: need to cast-away const of "buffer" parameter to match the C-API, the function does not modify it. */
342 return CVB_CALL_CAPI(MemoryToCLF(const_cast<void *>(buffer), static_cast<long>(size),
343 resclas)); // NOLINT(cppcoreguidelines-pro-type-const-cast)
344 });
345 }
346
348
353 template <class RANGE>
354 static typename TypedRange<std::unique_ptr<Classifier>, std::uint8_t, RANGE>::type FromBuffer(const RANGE &buffer)
355 {
356 auto bufferRange = MakeRangeAdapter<std::uint8_t>(buffer);
357 return FromBuffer(bufferRange.Data(), bufferRange.Size());
358 }
359
361
367 void *Handle() const noexcept
368 {
369 return shandle_.Handle();
370 }
371
373
380 static std::unique_ptr<Classifier> FromHandle(HandleGuard<Classifier> &&guard)
381 {
382 if (!guard.Handle())
383 {
384 throw std::invalid_argument("invalid clf classifier native handle");
385 }
386 return std::unique_ptr<Classifier>(new Classifier(std::move(guard)));
387 }
388
390
395 void Save(const String &fileName) const
396 {
397 CVB_CALL_CAPI_CHECKED(WriteCLFFileTyped(shandle_.Handle(), fileName.c_str()));
398 fileName_ = fileName;
399 }
400
402
408 {
409 auto sizeNeeded = CVB_CALL_CAPI(GetCLFSize(Handle()));
410 std::vector<std::uint8_t> buffer(sizeNeeded);
411 CVB_CALL_CAPI_CHECKED(CLFToMemory(shandle_.Handle(), buffer.data(), sizeNeeded));
412 return buffer;
413 }
414
417
422 {
423 return fileName_;
424 }
425
427
435 {
436 return models_;
437 }
438
440
444 Rect<int> Extent() const noexcept
445 {
446 return clfExtent_;
447 }
448
450
454 std::chrono::system_clock::time_point CreationDate() const noexcept
455 {
456 return creationDate_;
457 }
458
460
465 {
466 return CVB_CALL_CAPI(IsOldCLF(shandle_.Handle()) ? true : false);
467 }
468
470
474 int ContrastTrigger() const
475 {
476 CExports::cvbval_t retval = 0;
477 CVB_CALL_CAPI_CHECKED(GetCLFTrigger(shandle_.Handle(), retval));
478 return static_cast<int>(retval);
479 }
480
482
486 void SetContrastTrigger(int trigger)
487 {
488 CVB_CALL_CAPI_CHECKED(SetCLFTrigger(shandle_.Handle(), static_cast<CExports::cvbval_t>(trigger)));
489 }
490
492
496 double Threshold() const
497 {
499 CVB_CALL_CAPI_CHECKED(GetCLFThreshold(shandle_.Handle(), retval));
500 return retval;
501 }
502
504
508 void SetThreshold(double threshold)
509 {
510 CVB_CALL_CAPI_CHECKED(SetCLFThreshold(shandle_.Handle(), threshold));
511 }
512
514
519 {
520 CExports::QualityMeasureMethod retval = CExports::Quality_Unnormalized;
521 CVB_CALL_CAPI_CHECKED(GetCLFQualityType(shandle_.Handle(), retval));
522 return static_cast<QualityFeedback>(retval);
523 }
524
526
531 {
532 CVB_CALL_CAPI_CHECKED(
533 SetCLFQualityType(shandle_.Handle(), static_cast<CExports::QualityMeasureMethod>(quality)));
534 }
535
537
542 {
543 const Char *name = nullptr;
544 CVB_CALL_CAPI(CLFMTSNameTyped(shandle_.Handle(), name));
545 return (name != nullptr) ? String(name) : String();
546 }
547
549
554 {
555 CExports::TLearnControlStructure params{0};
556 CVB_CALL_CAPI_CHECKED(GetCLFLCS(shandle_.Handle(), params));
557 return Cvb::Minos::LearnParameters(params.Param6, params.Param5, params.Param4, params.Param3, params.Param1,
558 params.Param2 / 1000.0);
559 }
560
562
567 {
568 const Char *comment = nullptr;
569 CVB_CALL_CAPI(CLFCommentTyped(shandle_.Handle(), comment));
570 return (comment != nullptr) ? String(comment) : String();
571 }
572
574
578 void SetComment(String comment)
579 {
580 CVB_CALL_CAPI_CHECKED(SetCLFCommentTyped(shandle_.Handle(), comment.c_str()));
581 }
582
584
591 {
592 return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
593 /* Note: the binary compatibility between Matrix and TMatrix is guaranteed, therefore the cast below is legal.
594 */
595 return CVB_CALL_CAPI(
596 CLFTransform(Handle(), reinterpret_cast<const CExports::TMatrix &>(transformation), resclas));
597 });
598 }
599
602
609 {
610 return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
611 return CVB_CALL_CAPI(CLFSetGlobalAdvance(Handle(), static_cast<CExports::cvbdim_t>(advance.X()),
612 static_cast<CExports::cvbdim_t>(advance.Y()), resclas));
613 });
614 }
615
617
637 String Read(const ImagePlane &plane, ReadMode mode, Area2D startAOI, Area2D ocrAOI, SearchResult &startOrStop,
638 double density = 1.0)
639 {
640 double quality = 0.0, xPos = 0.0, yPos = 0.0, dX = 0.0, dY = 0.0;
641 Char *pstr = nullptr;
642 CExports::cvbval_t charCount = 0;
643 std::vector<Char> token(MaxSearch() + 1, 0);
644
645 /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the casts below are legal.
646 */
647 switch (mode)
648 {
650 CVB_CALL_CAPI_CHECKED(ReadTokenFirstTyped(
651 Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
652 reinterpret_cast<const CExports::TArea &>(startAOI), reinterpret_cast<const CExports::TArea &>(ocrAOI),
653 MaxSearch(), quality, xPos, yPos, dX, dY, pstr, charCount, token.data()));
654 break;
656 CVB_CALL_CAPI_CHECKED(ReadTokenTyped(
657 Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
658 reinterpret_cast<const CExports::TArea &>(startAOI), reinterpret_cast<const CExports::TArea &>(ocrAOI),
659 MaxSearch(), quality, xPos, yPos, dX, dY, pstr, charCount, token.data()));
660 break;
661 }
662
663 startOrStop = SearchResult(pstr, quality, Point2D<double>(xPos, yPos), Point2D<double>(dX, dY));
664 return String(token.data());
665 }
666
668
685 std::vector<SearchResult> Read(const ImagePlane &plane, Area2D startAOI, Area2D ocrAOI, double density = 1.0)
686 {
687 CExports::RESULTS hSearchResults = nullptr;
688 CVB_CALL_CAPI_CHECKED(
689 ReadCharacterList(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
690 reinterpret_cast<const CExports::TArea &>(startAOI),
691 reinterpret_cast<const CExports::TArea &>(ocrAOI), MaxSearch(), hSearchResults));
692 ReleaseObjectGuard hSearchResHolder(hSearchResults);
693 return Private::SearchResultsToArray(hSearchResults);
694 }
695
697
706 SearchResult Search(const ImagePlane &plane, SearchMode mode, Area2D aoi, double density = 1.0)
707 {
708 double quality = 0.0, xPos = 0.0, yPos = 0.0, dX = 0.0, dY = 0.0;
709 Char *pstr = nullptr;
710
711 /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the casts below are legal.
712 */
713 switch (mode)
714 {
716 CVB_CALL_CAPI_CHECKED(
717 SearchFirstTyped(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
718 reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
719 break;
721 CVB_CALL_CAPI_CHECKED(
722 SearchOptimumTyped(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
723 reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
724 break;
726 CVB_CALL_CAPI_CHECKED(SubpixelOptimumTyped(
727 Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
728 reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
729 break;
730 }
731
732 return SearchResult((pstr != nullptr) ? String(pstr) : String(), quality, Point2D<double>(xPos, yPos),
733 Point2D<double>(dX, dY));
734 }
735
737
745 SearchResult Search(const ImagePlane &plane, SearchMode mode, double density = 1.0)
746 {
747 return Search(plane, mode, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
748 }
749
751
760 std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, Area2D aoi, double density = 1.0)
761 {
762 /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
763 CExports::RESULTS hSearchResults = nullptr;
764 CVB_CALL_CAPI_CHECKED(
765 SearchAll(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
766 reinterpret_cast<const CExports::TArea &>(aoi), locality, MaxSearch(), hSearchResults));
767 ReleaseObjectGuard hSearchResHolder(hSearchResults);
768 return Private::SearchResultsToArray(hSearchResults);
769 }
770
772
780 std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, double density = 1.0)
781 {
782 return SearchAll(plane, locality, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
783 }
784
785 private:
786 SharedHandleGuard<Classifier> shandle_;
787 mutable String fileName_;
788 Rect<int> clfExtent_;
789 std::chrono::system_clock::time_point creationDate_;
791 }; /* class Classifier */
792
795
796 } /* namespace Minos */
797 CVB_END_INLINE_NS
798} /* namespace Cvb */
799
Structure that represents an area of interest in the image.
Definition area_2d.hpp:21
Rect< int > Bounds() const noexcept
Bounding rectangle of the image in pixels.
Definition decl_image.hpp:433
void * Handle() const noexcept
Classic API image handle.
Definition decl_image.hpp:232
Image plane information container.
Definition decl_image_plane.hpp:29
int Plane() const noexcept
Plane index in the image, to which this plane refers to.
Definition decl_image_plane.hpp:147
const Image & Parent() const noexcept
Image to which this plane descriptor refers to.
Definition detail_image_plane.hpp:87
Double precision 2x2 matrix class.
Definition matrix_2d.hpp:16
Minos classifier object.
Definition classifier.hpp:256
std::vector< SearchResult > Read(const ImagePlane &plane, Area2D startAOI, Area2D ocrAOI, double density=1.0)
Reads a list of characters.
Definition classifier.hpp:685
int ContrastTrigger() const
Get the trigger value for the contrast of features to be taken into account.
Definition classifier.hpp:474
static TypedRange< std::unique_ptr< Classifier >, std::uint8_t, RANGE >::type FromBuffer(const RANGE &buffer)
Recreate a serialized Minos classifier from a byte array.
Definition classifier.hpp:354
class LearnParameters LearnParameters() const
Get the set of parameters that has been used during classifier generation.
Definition classifier.hpp:553
std::unique_ptr< Classifier > Transform(Matrix2D transformation)
Generate a new classifier by transforming this classifier with a 2x2 transformation matrix.
Definition classifier.hpp:590
std::chrono::system_clock::time_point CreationDate() const noexcept
Creation date of the classifier.
Definition classifier.hpp:454
bool IsMinos16BitClassifier() const
Returns true if the classifier was generated by Minos16Bit.
Definition classifier.hpp:464
std::vector< SearchResult > SearchAll(const ImagePlane &plane, int locality, double density=1.0)
Search all objects using this Minos classifier.
Definition classifier.hpp:780
SearchResult Search(const ImagePlane &plane, SearchMode mode, double density=1.0)
Search one object using this Minos classifier.
Definition classifier.hpp:745
static std::unique_ptr< Classifier > FromHandle(HandleGuard< Classifier > &&guard)
Creates classifier from a classic API handle.
Definition classifier.hpp:380
void SetQualityMeasure(QualityFeedback quality)
Set the type of quality feedback from the classifier.
Definition classifier.hpp:530
SearchResult Search(const ImagePlane &plane, SearchMode mode, Area2D aoi, double density=1.0)
Search one object using this Minos classifier.
Definition classifier.hpp:706
String Comment() const
Get the comment assigned to the classifier at generation time.
Definition classifier.hpp:566
std::vector< std::uint8_t > ToBuffer() const
Builds a byte buffer with the classifier.
Definition classifier.hpp:407
void Save(const String &fileName) const
Write the classifier to a file.
Definition classifier.hpp:395
Classifier(const String &fileName)
Loads a classifier with the given file name.
Definition classifier.hpp:306
void SetComment(String comment)
Set the comment assigned to the classifier at generation time.
Definition classifier.hpp:578
double Threshold() const
Get the threshold for search operations with normalized quality feedback.
Definition classifier.hpp:496
static std::unique_ptr< Classifier > Load(const String &fileName)
Load a saved classifier from a file.
Definition classifier.hpp:324
String Read(const ImagePlane &plane, ReadMode mode, Area2D startAOI, Area2D ocrAOI, SearchResult &startOrStop, double density=1.0)
Reads a string of characters.
Definition classifier.hpp:637
ClassifierModelInfoCollection Models() const
Collection of the models contained in this classifier.
Definition classifier.hpp:434
void SetThreshold(double threshold)
Set the threshold for search operations with normalized quality feedback.
Definition classifier.hpp:508
std::unique_ptr< Classifier > SetGlobalAdvanceVector(Point2D< int > advance)
Create a new classifier, that is a copy of this classifier, but with a global advance vector applied ...
Definition classifier.hpp:608
std::vector< SearchResult > SearchAll(const ImagePlane &plane, int locality, Area2D aoi, double density=1.0)
Search all objects using this Minos classifier.
Definition classifier.hpp:760
Rect< int > Extent() const noexcept
Extent of the classes in the classifier relative to the anchor point.
Definition classifier.hpp:444
String FileName() const
Name of the file from which this classifier was loaded (empty string, if this image list was neither ...
Definition classifier.hpp:421
void * Handle() const noexcept
Classic API CLF handle.
Definition classifier.hpp:367
String TrainingSetName() const
Get name of the training set from which this classifier was generated.
Definition classifier.hpp:541
static std::unique_ptr< Classifier > FromBuffer(const void *buffer, size_t size)
Recreate a serialized Minos classifier from a byte array.
Definition classifier.hpp:338
QualityFeedback QualityMeasure() const
Get the type of quality feedback from the classifier.
Definition classifier.hpp:518
void SetContrastTrigger(int trigger)
Set the trigger value for the contrast of features to be taken into account.
Definition classifier.hpp:486
Collection of model information.
Definition classifier.hpp:172
ClassifierModelInfo ReadInfo(int index) const
Retrieves the indexed model information block.
Definition classifier.hpp:203
void WriteInfo(int index, ClassifierModelInfo model)
Writes the indexed model information block.
Definition classifier.hpp:220
int Count() const
Retrieves the number of elements in the collection.
Definition classifier.hpp:191
std::vector< ClassifierModelInfo > ReadInfo() const
Retrieves all the items stored in the collection.
Definition classifier.hpp:236
Information about a Minos classifier model.
Definition classifier.hpp:83
String Name() const
Get the name of the model.
Definition classifier.hpp:102
Point2D< int > AdvanceVector() const
Get the advance vector of the model.
Definition classifier.hpp:122
void SetAdvanceVector(Point2D< int > advanceVector)
Set the advance vector of the model.
Definition classifier.hpp:132
ClassifierModelInfo(const String &name, Point2D< int > advanceVector)
Create a new model information object.
Definition classifier.hpp:91
void SetName(const String &name)
Set the name of the model.
Definition classifier.hpp:112
The set of parameters, which controls, how a classifier is being learned from a training set.
Definition learn_parameters.hpp:19
Search result returned by Minos.
Definition search_result.hpp:25
Multi-purpose 2D vector class.
Definition point_2d.hpp:20
T X() const noexcept
Gets the x-component of the point.
Definition point_2d.hpp:84
T Y() const noexcept
Gets the y-component of the point.
Definition point_2d.hpp:104
Rectangle object.
Definition rect.hpp:24
T get_time(T... args)
cvbbool_t ReleaseObject(OBJ &Object)
T mktime(T... args)
T move(T... args)
Namespace for the Minos package.
Definition classifier.hpp:29
bool operator==(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept
Comparison operator for ClassifierModelInfo objects.
Definition classifier.hpp:163
SearchMode
Different modes for the search calls that return a single result.
Definition classifier.hpp:61
@ FindBest
Search the whole region of interest and return the best result.
Definition classifier.hpp:65
@ FindFirst
Stop after the first result has been found.
Definition classifier.hpp:63
@ FindBestSubPixel
Search the whole region of interest and return the best result with sub pixel accuracy.
Definition classifier.hpp:67
std::shared_ptr< Classifier > ClassifierPtr
Convenience shared pointer for Classifier.
Definition classifier.hpp:794
QualityFeedback
Feedback type for search functions.
Definition classifier.hpp:52
@ Normalized
Normalized quality feedback from correlation over a classifier's features in the range [0....
Definition classifier.hpp:56
@ Unnormalized
Unnormalized quality feedback in the range [0...255].
Definition classifier.hpp:54
ReadMode
Options for the read functions.
Definition classifier.hpp:72
@ ReturnFirstPosition
Return the position of the first character.
Definition classifier.hpp:74
@ ReturnLastPosition
Return the position of the last character.
Definition classifier.hpp:76
bool operator!=(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept
Comparison operator for ClassifierModelInfo objects.
Definition classifier.hpp:150
Root namespace for the Image Manager interface.
Definition c_bayer_to_rgb.h:17
char Char
Character type for wide characters or unicode characters.
Definition string.hpp:63
std::string String
String for wide characters or unicode characters.
Definition string.hpp:49
T quiet_NaN(T... args)