VisionControlStatus.hpp

Go to the documentation of this file.

/*
 * file VisionControlStatus.hpp
 *
 * This file was generated by classgenerator from vision_control_status.gen.
 * DO NOT CHANGE MANUALLY!
 *
 * Copyright © 2021 Eugene Gilmore. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgement:
 *
 *        This product includes software developed by Eugene Gilmore.
 *
 * 4. Neither the name of the author nor the names of contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * -----------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or
 * modify it under the above terms or under the terms of the GNU
 * General Public License as published by the Free Software Foundation;
 * either version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see http://www.gnu.org/licenses/
 * or write to the Free Software Foundation, Inc., 51 Franklin Street,
 * Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */
 
#ifndef guWhiteboard_VisionControlStatus_h
#define guWhiteboard_VisionControlStatus_h
 
#ifdef WHITEBOARD_POSTER_STRING_CONVERSION
#include <cstdlib>
#include <string.h>
#include <sstream>
#endif
 
#include <gu_util.h>
#include "wb_vision_control_status.h"
#include <float.h>
 
#undef guWhiteboard_VisionControlStatus_DEFINED
#define guWhiteboard_VisionControlStatus_DEFINED
 
#undef VisionControlStatus_DEFINED
#define VisionControlStatus_DEFINED
 
namespace guWhiteboard {
 
    class VisionControlStatus: public wb_vision_control_status {
 
    private:
 
        void init(enum Resolutions t_cameraResolution = VGA, bool t_pipelineRunning = true, enum VisionCamera t_selectedCamera = Top, enum SaveFileType t_saveImage = None, bool t_saveClassifiedImage = false, enum NamedPipeline t_pipeline = Soccer, int t_chooseCamera = 0, float t_confidence = 0.8f, enum NeuralNetworkType t_networkTop = v2, enum NeuralNetworkType t_networkBottom = v2, enum StreamingType t_streamingSource = Normal, bool t_imageInput = false, int t_jpegStreamQuality = 30, int t_jpegStreamStride = 4, int t_frameRate = 0, bool t_runPipelineOnce = false, uint64_t t_frameNumber = 0, std::string t_colourCalibration = "class", struct timeval t_imageTime = {}) {
            set_cameraResolution(t_cameraResolution);
            set_pipelineRunning(t_pipelineRunning);
            set_selectedCamera(t_selectedCamera);
            set_saveImage(t_saveImage);
            set_saveClassifiedImage(t_saveClassifiedImage);
            set_pipeline(t_pipeline);
            set_chooseCamera(t_chooseCamera);
            set_confidence(t_confidence);
            set_networkTop(t_networkTop);
            set_networkBottom(t_networkBottom);
            set_streamingSource(t_streamingSource);
            set_imageInput(t_imageInput);
            set_jpegStreamQuality(t_jpegStreamQuality);
            set_jpegStreamStride(t_jpegStreamStride);
            set_frameRate(t_frameRate);
            set_runPipelineOnce(t_runPipelineOnce);
            set_frameNumber(t_frameNumber);
            gu_strlcpy(const_cast<char *>(this->colourCalibration()), t_colourCalibration.c_str(), 10);
            set_imageTime(t_imageTime);
        }
 
    public:
 
        VisionControlStatus(enum Resolutions t_cameraResolution = VGA, bool t_pipelineRunning = true, enum VisionCamera t_selectedCamera = Top, enum SaveFileType t_saveImage = None, bool t_saveClassifiedImage = false, enum NamedPipeline t_pipeline = Soccer, int t_chooseCamera = 0, float t_confidence = 0.8f, enum NeuralNetworkType t_networkTop = v2, enum NeuralNetworkType t_networkBottom = v2, enum StreamingType t_streamingSource = Normal, bool t_imageInput = false, int t_jpegStreamQuality = 30, int t_jpegStreamStride = 4, int t_frameRate = 0, bool t_runPipelineOnce = false, uint64_t t_frameNumber = 0, std::string t_colourCalibration = "class", struct timeval t_imageTime = {}) {
            this->init(t_cameraResolution, t_pipelineRunning, t_selectedCamera, t_saveImage, t_saveClassifiedImage, t_pipeline, t_chooseCamera, t_confidence, t_networkTop, t_networkBottom, t_streamingSource, t_imageInput, t_jpegStreamQuality, t_jpegStreamStride, t_frameRate, t_runPipelineOnce, t_frameNumber, t_colourCalibration, t_imageTime);
        }
 
        VisionControlStatus(const VisionControlStatus &t_other): wb_vision_control_status() {
            this->init(t_other.cameraResolution(), t_other.pipelineRunning(), t_other.selectedCamera(), t_other.saveImage(), t_other.saveClassifiedImage(), t_other.pipeline(), t_other.chooseCamera(), t_other.confidence(), t_other.networkTop(), t_other.networkBottom(), t_other.streamingSource(), t_other.imageInput(), t_other.jpegStreamQuality(), t_other.jpegStreamStride(), t_other.frameRate(), t_other.runPipelineOnce(), t_other.frameNumber(), t_other.colourCalibration(), t_other.imageTime());
        }
 
        VisionControlStatus(const struct wb_vision_control_status &t_other): wb_vision_control_status() {
            this->init(t_other.cameraResolution, t_other.pipelineRunning, t_other.selectedCamera, t_other.saveImage, t_other.saveClassifiedImage, t_other.pipeline, t_other.chooseCamera, t_other.confidence, t_other.networkTop, t_other.networkBottom, t_other.streamingSource, t_other.imageInput, t_other.jpegStreamQuality, t_other.jpegStreamStride, t_other.frameRate, t_other.runPipelineOnce, t_other.frameNumber, t_other.colourCalibration, t_other.imageTime);
        }
 
        VisionControlStatus &operator = (const VisionControlStatus &t_other) {
            this->init(t_other.cameraResolution(), t_other.pipelineRunning(), t_other.selectedCamera(), t_other.saveImage(), t_other.saveClassifiedImage(), t_other.pipeline(), t_other.chooseCamera(), t_other.confidence(), t_other.networkTop(), t_other.networkBottom(), t_other.streamingSource(), t_other.imageInput(), t_other.jpegStreamQuality(), t_other.jpegStreamStride(), t_other.frameRate(), t_other.runPipelineOnce(), t_other.frameNumber(), t_other.colourCalibration(), t_other.imageTime());
            return *this;
        }
 
        VisionControlStatus &operator = (const struct wb_vision_control_status &t_other) {
            this->init(t_other.cameraResolution, t_other.pipelineRunning, t_other.selectedCamera, t_other.saveImage, t_other.saveClassifiedImage, t_other.pipeline, t_other.chooseCamera, t_other.confidence, t_other.networkTop, t_other.networkBottom, t_other.streamingSource, t_other.imageInput, t_other.jpegStreamQuality, t_other.jpegStreamStride, t_other.frameRate, t_other.runPipelineOnce, t_other.frameNumber, t_other.colourCalibration, t_other.imageTime);
            return *this;
        }
 
        bool operator ==(const VisionControlStatus &t_other) const
        {
            return cameraResolution() == t_other.cameraResolution()
                && pipelineRunning() == t_other.pipelineRunning()
                && selectedCamera() == t_other.selectedCamera()
                && saveImage() == t_other.saveImage()
                && saveClassifiedImage() == t_other.saveClassifiedImage()
                && pipeline() == t_other.pipeline()
                && chooseCamera() == t_other.chooseCamera()
                && fabsf(confidence() - t_other.confidence()) < FLT_EPSILON
                && networkTop() == t_other.networkTop()
                && networkBottom() == t_other.networkBottom()
                && streamingSource() == t_other.streamingSource()
                && imageInput() == t_other.imageInput()
                && jpegStreamQuality() == t_other.jpegStreamQuality()
                && jpegStreamStride() == t_other.jpegStreamStride()
                && frameRate() == t_other.frameRate()
                && runPipelineOnce() == t_other.runPipelineOnce()
                && frameNumber() == t_other.frameNumber()
                && 0 == strncmp(colourCalibration(), t_other.colourCalibration(), 10);
        }
 
        bool operator !=(const VisionControlStatus &t_other) const
        {
            return !(*this == t_other);
        }
 
        bool operator ==(const wb_vision_control_status &t_other) const
        {
            return *this == VisionControlStatus(t_other);
        }
 
        bool operator !=(const wb_vision_control_status &t_other) const
        {
            return !(*this == t_other);
        }
 
        enum Resolutions & cameraResolution()
        {
            return wb_vision_control_status::cameraResolution;
        }
 
        const enum Resolutions & cameraResolution() const
        {
            return wb_vision_control_status::cameraResolution;
        }
 
        void set_cameraResolution(const enum Resolutions &t_newValue)
        {
            wb_vision_control_status::cameraResolution = t_newValue;
        }
 
        bool & pipelineRunning()
        {
            return wb_vision_control_status::pipelineRunning;
        }
 
        const bool & pipelineRunning() const
        {
            return wb_vision_control_status::pipelineRunning;
        }
 
        void set_pipelineRunning(const bool &t_newValue)
        {
            wb_vision_control_status::pipelineRunning = t_newValue;
        }
 
        enum VisionCamera & selectedCamera()
        {
            return wb_vision_control_status::selectedCamera;
        }
 
        const enum VisionCamera & selectedCamera() const
        {
            return wb_vision_control_status::selectedCamera;
        }
 
        void set_selectedCamera(const enum VisionCamera &t_newValue)
        {
            wb_vision_control_status::selectedCamera = t_newValue;
        }
 
        enum SaveFileType & saveImage()
        {
            return wb_vision_control_status::saveImage;
        }
 
        const enum SaveFileType & saveImage() const
        {
            return wb_vision_control_status::saveImage;
        }
 
        void set_saveImage(const enum SaveFileType &t_newValue)
        {
            wb_vision_control_status::saveImage = t_newValue;
        }
 
        bool & saveClassifiedImage()
        {
            return wb_vision_control_status::saveClassifiedImage;
        }
 
        const bool & saveClassifiedImage() const
        {
            return wb_vision_control_status::saveClassifiedImage;
        }
 
        void set_saveClassifiedImage(const bool &t_newValue)
        {
            wb_vision_control_status::saveClassifiedImage = t_newValue;
        }
 
        enum NamedPipeline & pipeline()
        {
            return wb_vision_control_status::pipeline;
        }
 
        const enum NamedPipeline & pipeline() const
        {
            return wb_vision_control_status::pipeline;
        }
 
        void set_pipeline(const enum NamedPipeline &t_newValue)
        {
            wb_vision_control_status::pipeline = t_newValue;
        }
 
        int & chooseCamera()
        {
            return wb_vision_control_status::chooseCamera;
        }
 
        const int & chooseCamera() const
        {
            return wb_vision_control_status::chooseCamera;
        }
 
        void set_chooseCamera(const int &t_newValue)
        {
            wb_vision_control_status::chooseCamera = t_newValue;
        }
 
        float & confidence()
        {
            return wb_vision_control_status::confidence;
        }
 
        const float & confidence() const
        {
            return wb_vision_control_status::confidence;
        }
 
        void set_confidence(const float &t_newValue)
        {
            wb_vision_control_status::confidence = t_newValue;
        }
 
        enum NeuralNetworkType & networkTop()
        {
            return wb_vision_control_status::networkTop;
        }
 
        const enum NeuralNetworkType & networkTop() const
        {
            return wb_vision_control_status::networkTop;
        }
 
        void set_networkTop(const enum NeuralNetworkType &t_newValue)
        {
            wb_vision_control_status::networkTop = t_newValue;
        }
 
        enum NeuralNetworkType & networkBottom()
        {
            return wb_vision_control_status::networkBottom;
        }
 
        const enum NeuralNetworkType & networkBottom() const
        {
            return wb_vision_control_status::networkBottom;
        }
 
        void set_networkBottom(const enum NeuralNetworkType &t_newValue)
        {
            wb_vision_control_status::networkBottom = t_newValue;
        }
 
        enum StreamingType & streamingSource()
        {
            return wb_vision_control_status::streamingSource;
        }
 
        const enum StreamingType & streamingSource() const
        {
            return wb_vision_control_status::streamingSource;
        }
 
        void set_streamingSource(const enum StreamingType &t_newValue)
        {
            wb_vision_control_status::streamingSource = t_newValue;
        }
 
        bool & imageInput()
        {
            return wb_vision_control_status::imageInput;
        }
 
        const bool & imageInput() const
        {
            return wb_vision_control_status::imageInput;
        }
 
        void set_imageInput(const bool &t_newValue)
        {
            wb_vision_control_status::imageInput = t_newValue;
        }
 
        int & jpegStreamQuality()
        {
            return wb_vision_control_status::jpegStreamQuality;
        }
 
        const int & jpegStreamQuality() const
        {
            return wb_vision_control_status::jpegStreamQuality;
        }
 
        void set_jpegStreamQuality(const int &t_newValue)
        {
            wb_vision_control_status::jpegStreamQuality = t_newValue;
        }
 
        int & jpegStreamStride()
        {
            return wb_vision_control_status::jpegStreamStride;
        }
 
        const int & jpegStreamStride() const
        {
            return wb_vision_control_status::jpegStreamStride;
        }
 
        void set_jpegStreamStride(const int &t_newValue)
        {
            wb_vision_control_status::jpegStreamStride = t_newValue;
        }
 
        int & frameRate()
        {
            return wb_vision_control_status::frameRate;
        }
 
        const int & frameRate() const
        {
            return wb_vision_control_status::frameRate;
        }
 
        void set_frameRate(const int &t_newValue)
        {
            wb_vision_control_status::frameRate = t_newValue;
        }
 
        bool & runPipelineOnce()
        {
            return wb_vision_control_status::runPipelineOnce;
        }
 
        const bool & runPipelineOnce() const
        {
            return wb_vision_control_status::runPipelineOnce;
        }
 
        void set_runPipelineOnce(const bool &t_newValue)
        {
            wb_vision_control_status::runPipelineOnce = t_newValue;
        }
 
        uint64_t & frameNumber()
        {
            return wb_vision_control_status::frameNumber;
        }
 
        const uint64_t & frameNumber() const
        {
            return wb_vision_control_status::frameNumber;
        }
 
        void set_frameNumber(const uint64_t &t_newValue)
        {
            wb_vision_control_status::frameNumber = t_newValue;
        }
 
        const char * colourCalibration() const
        {
            return &(wb_vision_control_status::colourCalibration[0]);
        }
 
        size_t colourCalibration_size() const
        {
            return 10;
        }
 
        char & colourCalibration(int t_i)
        {
            return wb_vision_control_status::colourCalibration[t_i];
        }
 
        const char & colourCalibration(int t_i) const
        {
            return wb_vision_control_status::colourCalibration[t_i];
        }
 
        void set_colourCalibration(const char *t_newValue)
        {
            strncpy(wb_vision_control_status::colourCalibration, t_newValue, 10);
        }
 
        struct timeval & imageTime()
        {
            return wb_vision_control_status::imageTime;
        }
 
        const struct timeval & imageTime() const
        {
            return wb_vision_control_status::imageTime;
        }
 
        void set_imageTime(const struct timeval &t_newValue)
        {
            wb_vision_control_status::imageTime = t_newValue;
        }
 
#ifdef WHITEBOARD_POSTER_STRING_CONVERSION
        VisionControlStatus(const std::string &t_str) {
            this->init();
            this->from_string(t_str);
        }
 
        std::string description() {
#ifdef USE_WB_VISION_CONTROL_STATUS_C_CONVERSION
            char buffer[VISION_CONTROL_STATUS_DESC_BUFFER_SIZE];
            wb_vision_control_status_description(this, buffer, sizeof(buffer));
            std::string descr = buffer;
            return descr;
#else
            std::ostringstream ss;
            switch (this->cameraResolution()) {
                case HD_4VGA:
                {
                    ss << "cameraResolution=" << "HD_4VGA";
                    break;
                }
                case QQVGA:
                {
                    ss << "cameraResolution=" << "QQVGA";
                    break;
                }
                case QVGA:
                {
                    ss << "cameraResolution=" << "QVGA";
                    break;
                }
                case SVGA:
                {
                    ss << "cameraResolution=" << "SVGA";
                    break;
                }
                case VGA:
                {
                    ss << "cameraResolution=" << "VGA";
                    break;
                }
            }
            ss << ", ";
            ss << "pipelineRunning=" << (this->pipelineRunning() ? "true" : "false");
            ss << ", ";
            switch (this->selectedCamera()) {
                case Bottom:
                {
                    ss << "selectedCamera=" << "Bottom";
                    break;
                }
                case NUM_VISION_CAMERAS:
                {
                    ss << "selectedCamera=" << "NUM_VISION_CAMERAS";
                    break;
                }
                case Top:
                {
                    ss << "selectedCamera=" << "Top";
                    break;
                }
            }
            ss << ", ";
            switch (this->saveImage()) {
                case AI2:
                {
                    ss << "saveImage=" << "AI2";
                    break;
                }
                case AI3:
                {
                    ss << "saveImage=" << "AI3";
                    break;
                }
                case JPG:
                {
                    ss << "saveImage=" << "JPG";
                    break;
                }
                case None:
                {
                    ss << "saveImage=" << "None";
                    break;
                }
            }
            ss << ", ";
            ss << "saveClassifiedImage=" << (this->saveClassifiedImage() ? "true" : "false");
            ss << ", ";
            switch (this->pipeline()) {
                case HTWK:
                {
                    ss << "pipeline=" << "HTWK";
                    break;
                }
                case Neural_Network:
                {
                    ss << "pipeline=" << "Neural_Network";
                    break;
                }
                case OpenCVFaces:
                {
                    ss << "pipeline=" << "OpenCVFaces";
                    break;
                }
                case OpenChallenge:
                {
                    ss << "pipeline=" << "OpenChallenge";
                    break;
                }
                case Soccer:
                {
                    ss << "pipeline=" << "Soccer";
                    break;
                }
                case Streaming:
                {
                    ss << "pipeline=" << "Streaming";
                    break;
                }
            }
            ss << ", ";
            ss << "chooseCamera=" << static_cast<signed>(this->chooseCamera());
            ss << ", ";
            ss << "confidence=" << this->confidence();
            ss << ", ";
            switch (this->networkTop()) {
                case BallOnly:
                {
                    ss << "networkTop=" << "BallOnly";
                    break;
                }
                case VGANet:
                {
                    ss << "networkTop=" << "VGANet";
                    break;
                }
                case Vanilla:
                {
                    ss << "networkTop=" << "Vanilla";
                    break;
                }
                case v2:
                {
                    ss << "networkTop=" << "v2";
                    break;
                }
            }
            ss << ", ";
            switch (this->networkBottom()) {
                case BallOnly:
                {
                    ss << "networkBottom=" << "BallOnly";
                    break;
                }
                case VGANet:
                {
                    ss << "networkBottom=" << "VGANet";
                    break;
                }
                case Vanilla:
                {
                    ss << "networkBottom=" << "Vanilla";
                    break;
                }
                case v2:
                {
                    ss << "networkBottom=" << "v2";
                    break;
                }
            }
            ss << ", ";
            switch (this->streamingSource()) {
                case Classified:
                {
                    ss << "streamingSource=" << "Classified";
                    break;
                }
                case Normal:
                {
                    ss << "streamingSource=" << "Normal";
                    break;
                }
                case Recognized:
                {
                    ss << "streamingSource=" << "Recognized";
                    break;
                }
            }
            ss << ", ";
            ss << "imageInput=" << (this->imageInput() ? "true" : "false");
            ss << ", ";
            ss << "jpegStreamQuality=" << static_cast<signed>(this->jpegStreamQuality());
            ss << ", ";
            ss << "jpegStreamStride=" << static_cast<signed>(this->jpegStreamStride());
            ss << ", ";
            ss << "frameRate=" << static_cast<signed>(this->frameRate());
            ss << ", ";
            ss << "runPipelineOnce=" << (this->runPipelineOnce() ? "true" : "false");
            ss << ", ";
            ss << "frameNumber=" << this->frameNumber();
            ss << ", ";
            if (0 == strncmp("", this->colourCalibration(), 1)) {
                ss << "colourCalibration=" << "";
            } else {
                ss << "colourCalibration=" << this->colourCalibration();
            }
            return ss.str();
#endif 
        }
 
        std::string to_string() {
#ifdef USE_WB_VISION_CONTROL_STATUS_C_CONVERSION
            char buffer[VISION_CONTROL_STATUS_TO_STRING_BUFFER_SIZE];
            wb_vision_control_status_to_string(this, buffer, sizeof(buffer));
            std::string toString = buffer;
            return toString;
#else
            std::ostringstream ss;
            switch (this->cameraResolution()) {
                case HD_4VGA:
                {
                    ss << "HD_4VGA";
                    break;
                }
                case QQVGA:
                {
                    ss << "QQVGA";
                    break;
                }
                case QVGA:
                {
                    ss << "QVGA";
                    break;
                }
                case SVGA:
                {
                    ss << "SVGA";
                    break;
                }
                case VGA:
                {
                    ss << "VGA";
                    break;
                }
            }
            ss << ", ";
            ss << (this->pipelineRunning() ? "true" : "false");
            ss << ", ";
            switch (this->selectedCamera()) {
                case Bottom:
                {
                    ss << "Bottom";
                    break;
                }
                case NUM_VISION_CAMERAS:
                {
                    ss << "NUM_VISION_CAMERAS";
                    break;
                }
                case Top:
                {
                    ss << "Top";
                    break;
                }
            }
            ss << ", ";
            switch (this->saveImage()) {
                case AI2:
                {
                    ss << "AI2";
                    break;
                }
                case AI3:
                {
                    ss << "AI3";
                    break;
                }
                case JPG:
                {
                    ss << "JPG";
                    break;
                }
                case None:
                {
                    ss << "None";
                    break;
                }
            }
            ss << ", ";
            ss << (this->saveClassifiedImage() ? "true" : "false");
            ss << ", ";
            switch (this->pipeline()) {
                case HTWK:
                {
                    ss << "HTWK";
                    break;
                }
                case Neural_Network:
                {
                    ss << "Neural_Network";
                    break;
                }
                case OpenCVFaces:
                {
                    ss << "OpenCVFaces";
                    break;
                }
                case OpenChallenge:
                {
                    ss << "OpenChallenge";
                    break;
                }
                case Soccer:
                {
                    ss << "Soccer";
                    break;
                }
                case Streaming:
                {
                    ss << "Streaming";
                    break;
                }
            }
            ss << ", ";
            ss << static_cast<signed>(this->chooseCamera());
            ss << ", ";
            ss << this->confidence();
            ss << ", ";
            switch (this->networkTop()) {
                case BallOnly:
                {
                    ss << "BallOnly";
                    break;
                }
                case VGANet:
                {
                    ss << "VGANet";
                    break;
                }
                case Vanilla:
                {
                    ss << "Vanilla";
                    break;
                }
                case v2:
                {
                    ss << "v2";
                    break;
                }
            }
            ss << ", ";
            switch (this->networkBottom()) {
                case BallOnly:
                {
                    ss << "BallOnly";
                    break;
                }
                case VGANet:
                {
                    ss << "VGANet";
                    break;
                }
                case Vanilla:
                {
                    ss << "Vanilla";
                    break;
                }
                case v2:
                {
                    ss << "v2";
                    break;
                }
            }
            ss << ", ";
            switch (this->streamingSource()) {
                case Classified:
                {
                    ss << "Classified";
                    break;
                }
                case Normal:
                {
                    ss << "Normal";
                    break;
                }
                case Recognized:
                {
                    ss << "Recognized";
                    break;
                }
            }
            ss << ", ";
            ss << (this->imageInput() ? "true" : "false");
            ss << ", ";
            ss << static_cast<signed>(this->jpegStreamQuality());
            ss << ", ";
            ss << static_cast<signed>(this->jpegStreamStride());
            ss << ", ";
            ss << static_cast<signed>(this->frameRate());
            ss << ", ";
            ss << (this->runPipelineOnce() ? "true" : "false");
            ss << ", ";
            ss << this->frameNumber();
            ss << ", ";
            if (0 == strncmp("", this->colourCalibration(), 1)) {
                ss << "";
            } else {
                ss << this->colourCalibration();
            }
            return ss.str();
#endif 
        }
 
#ifdef USE_WB_VISION_CONTROL_STATUS_C_CONVERSION
        void from_string(const std::string &t_str) {
            wb_vision_control_status_from_string(this, t_str.c_str());
#else
        void from_string(const std::string &t_str) {
            char * str_cstr = const_cast<char *>(t_str.c_str());
            size_t temp_length = strlen(str_cstr);
            int length = (temp_length <= INT_MAX) ? static_cast<int>(static_cast<ssize_t>(temp_length)) : -1;
            if (length < 1 || length > VISION_CONTROL_STATUS_DESC_BUFFER_SIZE) {
                return;
            }
            char var_str_buffer[VISION_CONTROL_STATUS_DESC_BUFFER_SIZE + 1];
            char* var_str = &var_str_buffer[0];
            char key_buffer[20];
            char* key = &key_buffer[0];
            int bracecount = 0;
            int startVar = 0;
            int index = 0;
            int startKey = 0;
            int endKey = -1;
            int varIndex = 0;
            if (index == 0 && str_cstr[0] == '{') {
                index = 1;
            }
            startVar = index;
            startKey = startVar;
            do {
                for (int i = index; i < length; i++) {
                    index = i + 1;
                    if (bracecount == 0 && str_cstr[i] == '=') {
                        endKey = i - 1;
                        startVar = index;
                        continue;
                    }
                    if (bracecount == 0 && isspace(str_cstr[i])) {
                        startVar = index;
                        if (endKey == -1) {
                            startKey = index;
                        }
                        continue;
                    }
                    if (bracecount == 0 && str_cstr[i] == ',') {
                        index = i - 1;
                        break;
                    }
                    if (str_cstr[i] == '{') {
                        bracecount++;
                        continue;
                    }
                    if (str_cstr[i] == '}') {
                        bracecount--;
                        if (bracecount < 0) {
                            index = i - 1;
                            break;
                        }
                    }
                    if (i == length - 1) {
                        index = i;
                    }
                }
                if (endKey >= startKey && endKey - startKey < length) {
                    strncpy(key, str_cstr + startKey, static_cast<size_t>((endKey - startKey) + 1));
                    key[(endKey - startKey) + 1] = 0;
                } else {
                    key[0] = 0;
                }
                strncpy(var_str, str_cstr + startVar, static_cast<size_t>((index - startVar) + 1));
                var_str[(index - startVar) + 1] = 0;
                bracecount = 0;
                index += 2;
                startVar = index;
                startKey = startVar;
                endKey = -1;
                if (strlen(key) > 0) {
                    if (0 == strcmp("cameraResolution", key)) {
                        varIndex = 0;
                    } else if (0 == strcmp("pipelineRunning", key)) {
                        varIndex = 1;
                    } else if (0 == strcmp("selectedCamera", key)) {
                        varIndex = 2;
                    } else if (0 == strcmp("saveImage", key)) {
                        varIndex = 3;
                    } else if (0 == strcmp("saveClassifiedImage", key)) {
                        varIndex = 4;
                    } else if (0 == strcmp("pipeline", key)) {
                        varIndex = 5;
                    } else if (0 == strcmp("chooseCamera", key)) {
                        varIndex = 6;
                    } else if (0 == strcmp("confidence", key)) {
                        varIndex = 7;
                    } else if (0 == strcmp("networkTop", key)) {
                        varIndex = 8;
                    } else if (0 == strcmp("networkBottom", key)) {
                        varIndex = 9;
                    } else if (0 == strcmp("streamingSource", key)) {
                        varIndex = 10;
                    } else if (0 == strcmp("imageInput", key)) {
                        varIndex = 11;
                    } else if (0 == strcmp("jpegStreamQuality", key)) {
                        varIndex = 12;
                    } else if (0 == strcmp("jpegStreamStride", key)) {
                        varIndex = 13;
                    } else if (0 == strcmp("frameRate", key)) {
                        varIndex = 14;
                    } else if (0 == strcmp("runPipelineOnce", key)) {
                        varIndex = 15;
                    } else if (0 == strcmp("frameNumber", key)) {
                        varIndex = 16;
                    } else if (0 == strcmp("colourCalibration", key)) {
                        varIndex = 17;
                    } else {
                        varIndex = -1;
                    }
                }
                switch (varIndex) {
                    case -1: { break; }
                    case 0:
                    {
                        if (strcmp("HD_4VGA", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(HD_4VGA);
#pragma clang diagnostic pop
                        } else if (strcmp("QQVGA", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(QQVGA);
#pragma clang diagnostic pop
                        } else if (strcmp("QVGA", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(QVGA);
#pragma clang diagnostic pop
                        } else if (strcmp("SVGA", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(SVGA);
#pragma clang diagnostic pop
                        } else if (strcmp("VGA", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(VGA);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_cameraResolution(static_cast<enum Resolutions>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 1:
                    {
                        this->set_pipelineRunning(strcmp(var_str, "true") == 0 || strcmp(var_str, "1") == 0);
                        break;
                    }
                    case 2:
                    {
                        if (strcmp("Bottom", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_selectedCamera(Bottom);
#pragma clang diagnostic pop
                        } else if (strcmp("NUM_VISION_CAMERAS", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_selectedCamera(NUM_VISION_CAMERAS);
#pragma clang diagnostic pop
                        } else if (strcmp("Top", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_selectedCamera(Top);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_selectedCamera(static_cast<enum VisionCamera>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 3:
                    {
                        if (strcmp("AI2", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_saveImage(AI2);
#pragma clang diagnostic pop
                        } else if (strcmp("AI3", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_saveImage(AI3);
#pragma clang diagnostic pop
                        } else if (strcmp("JPG", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_saveImage(JPG);
#pragma clang diagnostic pop
                        } else if (strcmp("None", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_saveImage(None);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_saveImage(static_cast<enum SaveFileType>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 4:
                    {
                        this->set_saveClassifiedImage(strcmp(var_str, "true") == 0 || strcmp(var_str, "1") == 0);
                        break;
                    }
                    case 5:
                    {
                        if (strcmp("HTWK", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(HTWK);
#pragma clang diagnostic pop
                        } else if (strcmp("Neural_Network", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(Neural_Network);
#pragma clang diagnostic pop
                        } else if (strcmp("OpenCVFaces", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(OpenCVFaces);
#pragma clang diagnostic pop
                        } else if (strcmp("OpenChallenge", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(OpenChallenge);
#pragma clang diagnostic pop
                        } else if (strcmp("Soccer", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(Soccer);
#pragma clang diagnostic pop
                        } else if (strcmp("Streaming", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(Streaming);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_pipeline(static_cast<enum NamedPipeline>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 6:
                    {
                        this->set_chooseCamera(static_cast<int>(atoi(var_str)));
                        break;
                    }
                    case 7:
                    {
                        this->set_confidence(static_cast<float>(atof(var_str)));
                        break;
                    }
                    case 8:
                    {
                        if (strcmp("BallOnly", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkTop(BallOnly);
#pragma clang diagnostic pop
                        } else if (strcmp("VGANet", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkTop(VGANet);
#pragma clang diagnostic pop
                        } else if (strcmp("Vanilla", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkTop(Vanilla);
#pragma clang diagnostic pop
                        } else if (strcmp("v2", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkTop(v2);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkTop(static_cast<enum NeuralNetworkType>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 9:
                    {
                        if (strcmp("BallOnly", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkBottom(BallOnly);
#pragma clang diagnostic pop
                        } else if (strcmp("VGANet", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkBottom(VGANet);
#pragma clang diagnostic pop
                        } else if (strcmp("Vanilla", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkBottom(Vanilla);
#pragma clang diagnostic pop
                        } else if (strcmp("v2", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkBottom(v2);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_networkBottom(static_cast<enum NeuralNetworkType>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 10:
                    {
                        if (strcmp("Classified", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_streamingSource(Classified);
#pragma clang diagnostic pop
                        } else if (strcmp("Normal", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_streamingSource(Normal);
#pragma clang diagnostic pop
                        } else if (strcmp("Recognized", var_str) == 0) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_streamingSource(Recognized);
#pragma clang diagnostic pop
                        } else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbad-function-cast"
                        this->set_streamingSource(static_cast<enum StreamingType>(atoi(var_str)));
#pragma clang diagnostic pop
                        }
                        break;
                    }
                    case 11:
                    {
                        this->set_imageInput(strcmp(var_str, "true") == 0 || strcmp(var_str, "1") == 0);
                        break;
                    }
                    case 12:
                    {
                        this->set_jpegStreamQuality(static_cast<int>(atoi(var_str)));
                        break;
                    }
                    case 13:
                    {
                        this->set_jpegStreamStride(static_cast<int>(atoi(var_str)));
                        break;
                    }
                    case 14:
                    {
                        this->set_frameRate(static_cast<int>(atoi(var_str)));
                        break;
                    }
                    case 15:
                    {
                        this->set_runPipelineOnce(strcmp(var_str, "true") == 0 || strcmp(var_str, "1") == 0);
                        break;
                    }
                    case 16:
                    {
#ifdef __APPLE__
                        this->set_frameNumber(static_cast<uint64_t>(atoll(var_str)));
#else
                        this->set_frameNumber(static_cast<uint64_t>(atol(var_str)));
#endif
                        break;
                    }
                    case 17:
                    {
                        strncpy(wb_vision_control_status::colourCalibration, var_str, 10);
                        break;
                    }
                }
                if (varIndex >= 0) {
                    varIndex++;
                }
            } while(index < length);
#endif 
        }
#endif 
    };
 
    class ResolutionType {
    private:
        PROPERTY(Resolutions, resolution)
    public:
        ResolutionType(Resolutions res = VGA): _resolution(res) {}
 
        int width() const
        {
            static const int Widths[] = {160, 320, 640, 1280, 800};
            return Widths[_resolution];
        }
 
        int height() const
        {
            static const int Heights[] = {120, 240, 480, 960, 600};
            return Heights[_resolution];
        }
    };
 
} 
 
#endif