Qt编程：ImagePlay中的IPLProcessProperty类

最新推荐文章于 2025-07-26 11:04:55 发布
最新推荐文章于 2025-07-26 11:04:55 发布
阅读量920 收藏 11
点赞数 34
CC 4.0 BY-SA版权
分类专栏： 可视化编程 文章标签： qt ImagePlay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WaitingHereFor/article/details/149385603

IPLProcessProperty 是 ImagePlay 框架中用于处理图像处理算法属性的基类系统。它提供了一套完整的属性管理机制，支持多种数据类型和 GUI 控件类型。

主要功能

  1. 属性管理：为图像处理算法提供可配置的参数

  2. 序列化/反序列化：支持属性的保存和加载

  3. GUI 集成：与用户界面控件绑定

  4. 事件通知：属性变化时通知相关组件

//#############################################################################
//
//  This file is part of ImagePlay.
//
//  ImagePlay is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  ImagePlay 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 ImagePlay.  If not, see <http://www.gnu.org/licenses/>.
//
//#############################################################################

#ifndef IPLPROCESSPROPERTY_H
#define IPLPROCESSPROPERTY_H

#include "IPLProcess.h"
#include "IPLColor.h"
#include "IPLPoint.h"

#include <cstring>
#include <string>
#include <map>
#include <sstream>
#include <vector>
#include <memory>

class IPLProcess;


// we need a base class in order to use the template in std::map
class IPLSHARED_EXPORT IPLProcessProperty
{
public:
    struct SerializedData
    {
        std::string type;
        std::string widget;
        std::string widgetName;
        std::string value;
    };

    struct DeserialationFailed : public std::runtime_error
    { DeserialationFailed(): std::runtime_error("") {} };

    int position() const                  { return _position; }
    const char* name() const              { return _name; }
    const char* title() const             { return _title; }
    const char* description() const       { return _description; }
    IPLProcessWidgetType widget() const   { return _widget; }
    virtual const char* type() const = 0;
    virtual SerializedData serialize() const = 0;
    virtual void deserialize(const SerializedData &data) = 0;
    virtual IPLProcessProperty *clone() const = 0;
    virtual void resetValue() = 0;

protected:
    IPLProcessProperty(int position,
                       const char *name,
                       const char *title,
                       const char *description,
                       IPLProcess *process,
                       IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    int _position;                  //!< Position in GUI
    const char* _name;              //!< ID for GUI
    const char* _title;             //!< Short title for GUI
    const char* _description;       //!< Short help for GUI
    IPLProcess*  _process;
    IPLProcessWidgetType _widget;
};


// templates are not possible because of serialization issues

// INT
class IPLSHARED_EXPORT IPLProcessPropertyInt : public IPLProcessProperty
{
public:
    IPLProcessPropertyInt(IPLProcess* process, int position, const char* name, const char* title, const char* description, int value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT, int min=0, int max=0);

    int min() const                         { return _min; }
    int max() const                         { return _max; }
    int value() const                       { return _value; }
    void setValue(int value);
    void resetValue()                       { setValue(_default); }
    virtual const char *type() const        { return "int"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    int _min;                         //!< min value, may be used in GUI
    int _max;                         //!< max value, may be used in GUI
    int _value;                       //!< current value
    int _default;                     //!< default value
};

// UNSIGNED INT
class IPLSHARED_EXPORT IPLProcessPropertyUnsignedInt: public IPLProcessProperty
{
public:
    IPLProcessPropertyUnsignedInt(IPLProcess* process, int position, const char* name, const char* title, const char* description, unsigned int value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT, unsigned int min=0, unsigned int max=0);

    unsigned int min() const                         { return _min; }
    unsigned int max() const                         { return _max; }
    unsigned int value() const                       { return _value; }
    void setValue(unsigned int value);
    void resetValue()                                { setValue(_default); }
    virtual const char *type() const                 { return "uint"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    unsigned int _min;                         //!< min value, may be used in GUI
    unsigned int _max;                         //!< max value, may be used in GUI
    unsigned int _value;                       //!< current value
    unsigned int _default;                     //!< default value
};

// DOUBLE
class IPLSHARED_EXPORT IPLProcessPropertyDouble : public IPLProcessProperty
{
public:
    IPLProcessPropertyDouble(IPLProcess* process, int position, const char* name, const char* title, const char* description, double value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT, double min=0.0, double max=0.0);

    double min() const                         { return _min; }
    double max() const                         { return _max; }
    double value() const                       { return _value; }
    void setValue(double value);
    void resetValue()                          { setValue(_default); }
    virtual const char *type() const           { return "double"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    double _min;                         //!< min value, may be used in GUI
    double _max;                         //!< max value, may be used in GUI
    double _value;                       //!< current value
    double _default;                     //!< default value
};

// DOUBLE
class IPLSHARED_EXPORT IPLProcessPropertyFloat : public IPLProcessProperty
{
public:
    IPLProcessPropertyFloat(IPLProcess* process, int position, const char* name, const char* title, const char* description, float value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT,  float min=0.0f, float max=0.0f);

    float min() const                         { return _min; }
    float max() const                         { return _max; }
    float value() const                       { return _value; }
    void setValue(float value);
    void resetValue()                         { setValue(_default); }
    virtual const char *type() const          { return "float"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    float _min;                         //!< min value, may be used in GUI
    float _max;                         //!< max value, may be used in GUI
    float _value;                       //!< current value
    float _default;                     //!< default value
};



// BOOL
class IPLSHARED_EXPORT IPLProcessPropertyBool : public IPLProcessProperty
{
public:
    IPLProcessPropertyBool(IPLProcess* process, int position, const char* name, const char* title, const char* description, bool value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    bool value() const                       { return _value; }
    void setValue(bool value);
    void resetValue()                        { setValue(_default); }
    virtual const char *type() const         { return "bool"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

protected:
    bool _value;                       //!< current value
    bool _default;                     //!< default value
};

// BOOL ONE SHOT
class IPLSHARED_EXPORT IPLProcessPropertyBoolOneShot : public IPLProcessPropertyBool
{
public:
    IPLProcessPropertyBoolOneShot(IPLProcess* process, int position, const char* name, const char* title, const char* description, bool value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);
    bool value()                             { bool ret = _value; _value = false; return ret; }
};

// STRING
class IPLSHARED_EXPORT IPLProcessPropertyString : public IPLProcessProperty
{
public:
    IPLProcessPropertyString(IPLProcess* process, int position, const char* name, const char* title, const char* description, const std::string &value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    std::string value() const                       { return _value; }
    void setValue(const std::string &value);
    void setValue(std::string &&value);
    void resetValue()                               { setValue(_default); }
    virtual const char *type() const                { return "string"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    std::string _value;                       //!< current value
    std::string _default;                     //!< default value
};


// VECTOR<INT>
class IPLSHARED_EXPORT IPLProcessPropertyVectorInt : public IPLProcessProperty
{
public:
    IPLProcessPropertyVectorInt(IPLProcess* process, int position, const char* name, const char* title, const char* description, const std::vector<int> &value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    const std::vector<int> &value() const                       { return _value; }
    void setValue(const std::vector<int> &value);
    void setValue(std::vector<int> &&value);
    void resetValue()                                           { setValue(_default); }
    virtual const char *type() const                            { return "vector<int>"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    std::vector<int> _value;                       //!< current value
    std::vector<int> _default;                     //!< default value
};

// VECTOR<DOUBLE>
class IPLSHARED_EXPORT IPLProcessPropertyVectorDouble : public IPLProcessProperty
{
public:
    IPLProcessPropertyVectorDouble(IPLProcess* process, int position, const char* name, const char* title, const char* description, const std::vector<double> &value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    const std::vector<double> &value() const                    { return _value; }
    void setValue(const std::vector<double> &value);
    void setValue(std::vector<double> &&value);
    void resetValue()                                           { setValue(_default); }
    virtual const char *type() const                            { return "vector<double>"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    std::vector<double> _value;                       //!< current value
    std::vector<double> _default;                     //!< default value
};

// COLOR
class IPLSHARED_EXPORT IPLProcessPropertyColor : public IPLProcessProperty
{
public:
    IPLProcessPropertyColor(IPLProcess* process, int position, const char* name, const char* title, const char* description, const IPLColor &value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    const IPLColor &value() const                       { return _value; }
    void setValue(const IPLColor &value);
    void setValue(IPLColor &&value);
    void resetValue()                                   { setValue(_default); }
    virtual const char *type() const                    { return "color"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    IPLColor _value;                       //!< current value
    IPLColor _default;                     //!< default value
};


// POINT
class IPLSHARED_EXPORT IPLProcessPropertyPoint : public IPLProcessProperty
{
public:
    IPLProcessPropertyPoint(IPLProcess* process, int position, const char* name, const char* title, const char* description, const IPLPoint &value, IPLProcessWidgetType widget = IPL_WIDGET_DEFAULT);

    const IPLPoint &value() const                       { return _value; }
    void setValue(const IPLPoint &value);
    void setValue(IPLPoint &&value);
    void resetValue()                                   { setValue(_default); }
    virtual const char *type() const                    { return "point"; }
    virtual SerializedData serialize() const;
    virtual void deserialize(const SerializedData &data);
    IPLProcessProperty *clone() const;

private:
    IPLPoint _value;                       //!< current value
    IPLPoint _default;                     //!< default value
};

//! IPLProcessPropertyMap
typedef std::map<std::string, std::shared_ptr<IPLProcessProperty>> IPLProcessPropertyMap;


#endif // IPLPROCESSPROPERTY_H

//#############################################################################
//
//  This file is part of ImagePlay.
//
//  ImagePlay is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  ImagePlay 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 ImagePlay.  If not, see <http://www.gnu.org/licenses/>.
//
//#############################################################################

#include "IPLProcessProperty.h"

#include <array>
#include <cctype>
#include <regex>

template<class T>
inline std::string serializeValue(const T &value)
{
    std::ostringstream buffer;
    buffer << value;
    return buffer.str();
}

template<>
inline std::string serializeValue<bool>(const bool &value)
{
    std::ostringstream buffer;
    buffer <<  (value ? "true" : "false");
    return buffer.str();
}

template<>
inline std::string serializeValue<std::vector<int>>(const std::vector<int> &value)
{
    std::ostringstream buffer;
    buffer << "[";
    if (value.size() > 0) buffer << value[0];
    for (int i = 1; i < (int) value.size(); ++i) buffer << "," << value[i];
    buffer << "]";
    return buffer.str();
}

template<>
inline std::string serializeValue<std::vector<double>>(const std::vector<double> &value)
{
    std::ostringstream buffer;
    buffer << "[";
    if (value.size() > 0) buffer << value[0];
    for (int i = 1; i < (int) value.size(); ++i) buffer << "," << value[i];
    buffer << "]";
    return buffer.str();
}

template<>
inline std::string serializeValue<IPLColor>(const IPLColor &value)
{
    std::ostringstream buffer;
    buffer << "[" << value.red() << "," << value.green() << "," << value.blue() << "]";
    return buffer.str();
}

template<>
inline std::string serializeValue<IPLPoint>(const IPLPoint &value)
{
    std::ostringstream buffer;
    buffer << "[" << value.x() << "," << value.y() << "]";
    return buffer.str();
}

template<class T>
inline IPLProcessProperty::SerializedData serializeProperty(const char *type, IPLProcessWidgetType widget, const T &value)
{
    IPLProcessProperty::SerializedData result;
    result.type = serializeValue(type);
    result.widget = serializeValue(widget);
    result.widgetName = serializeValue(widgetName(widget));
    result.value = serializeValue(value);
    return result;
}

inline void deserializeValue(const std::string &data, bool &value)
{
    /*if (data.length() != 4)
    {
        value = false;
        return;
    }*/

    //static const unsigned char nonAsciiMap = 1<<7;
    std::string lowercase(data);
    //tolower is undefined (i.e. might crash) for non-ASCII characters. Since we don't want to parse those, just xor them out
    //std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(), [](char c) { return c ^ nonAsciiMap; });
    std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(), tolower); //Transform to lower case
    value = (lowercase.compare("true") == 0 || lowercase.compare("1") == 0);
}

inline void deserializeValue(const std::string &data, int &value)
{
    int result = 0;
    if (sscanf(data.c_str(),"%d",&result) < 1)
        throw IPLProcessProperty::DeserialationFailed();
    value = result;
}

inline void deserializeValue(const std::string &data, IPLProcessWidgetType &value)
{
    int tmp;
    deserializeValue(data,tmp);
    value = (IPLProcessWidgetType) tmp;
}

inline void deserializeValue(const std::string &data, unsigned int &value)
{
    unsigned int result = 0;
    if (sscanf(data.c_str(),"%u",&result) < 1)
        throw IPLProcessProperty::DeserialationFailed();
    value = result;
}

inline void deserializeValue(const std::string &data, float &value)
{
    float result = 0;
    if (sscanf(data.c_str(),"%f",&result) < 1)
        throw IPLProcessProperty::DeserialationFailed();
    value = result;
}

inline void deserializeValue(const std::string &data, double &value)
{
    double result = 0;
    if (sscanf(data.c_str(),"%lf",&result) < 1)
        throw IPLProcessProperty::DeserialationFailed();
    value = result;
}

inline void deserializeValue(const std::string &data, std::vector<int> &value)
{
    std::vector<int> result;
    std::smatch match;
    auto pos = data.begin();
    while(std::regex_search(pos,data.end(),match,std::regex("[0-9]|-")))
    {
        pos += match.position();

        int charsParsed = 0;
        int element = 0;
        if (sscanf(&(*pos),"%d%n",&element,&charsParsed) > 0)
            result.push_back(element);

        pos += charsParsed;
    }
    value.swap(result);
}

inline void deserializeValue(const std::string &data, std::vector<double> &value)
{
    std::vector<double> result;
    std::smatch match;
    auto pos = data.begin();
    while(std::regex_search(pos,data.end(),match,std::regex("[0-9]|-")))
    {
        pos += match.position();

        int charsParsed = 0;
        double element = 0;
        if (sscanf(&(*pos),"%f%n",&element,&charsParsed) > 0)
            result.push_back(element);

        pos += charsParsed;
    }
    value.swap(result);
}

inline void deserializeValue(const std::string &data, IPLColor &value)
{
    std::array<float,3> color;

    int i = 0;
    std::smatch match;
    auto pos = data.begin();
    while(i < (int) color.size() && std::regex_search(pos,data.end(),match,std::regex("[-0-9.]")))
    {
        pos += match.position();

        int charsParsed = 0;
        float element = 0;
        if (sscanf(&(*pos),"%f%n",&element,&charsParsed) > 0)
            color[i++] = element;

        pos += charsParsed;
    }
    value = IPLColor(color[0], color[1], color[2]);
}

inline void deserializeValue(const std::string &data, IPLPoint &value)
{
    std::array<double,2> point;

    int i = 0;
    std::smatch match;
    auto pos = data.begin();
    while(i < (int) point.size() && std::regex_search(pos,data.end(),match,std::regex("[-0-9.]")))
    {
        pos += match.position();

        int charsParsed = 0;
        float element = 0;
        if (sscanf(&(*pos),"%f%n",&element,&charsParsed) > 0)
            point[i++] = element;

        pos += charsParsed;
    }

    value = IPLPoint(point[0], point[1]);
}

inline void deserializeValue(const std::string &data, std::string &value)
{
    value = data;
}

template<class T>
inline void deserializeProperty(IPLProcessProperty::SerializedData data, IPLProcessWidgetType &widget, T &value)
{
    deserializeValue(data.widget,widget);
    deserializeValue(data.value,value);
}

IPLProcessProperty::IPLProcessProperty(int position, const char* name, const char *title, const char *description, IPLProcess *process, IPLProcessWidgetType widget):
    _position(position),
    _name(name),
    _title(title),
    _description(description),
    _process(process),
    _widget(widget)
{}

IPLProcessPropertyInt::IPLProcessPropertyInt(IPLProcess *process, int position, const char* name, const char* title, const char *description, int value, IPLProcessWidgetType widget, int min, int max):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value),
    _min(min),
    _max(max)
{}

void IPLProcessPropertyInt::setValue(int value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyInt::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyInt::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyInt::clone() const
{
    return new IPLProcessPropertyInt(*this);
}

IPLProcessPropertyUnsignedInt::IPLProcessPropertyUnsignedInt(IPLProcess *process, int position, const char* name, const char* title, const char *description, unsigned int value, IPLProcessWidgetType widget, unsigned int min, unsigned int max):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value),
    _min(min),
    _max(max)
{}

void IPLProcessPropertyUnsignedInt::setValue(unsigned int value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyUnsignedInt::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyUnsignedInt::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyUnsignedInt::clone() const
{
    return new IPLProcessPropertyUnsignedInt(*this);
}


IPLProcessPropertyDouble::IPLProcessPropertyDouble(IPLProcess *process, int position, const char* name, const char* title, const char *description, double value, IPLProcessWidgetType widget, double min, double max):
    IPLProcessProperty(position,name,title,description,process, widget),
    _value(value),
    _default(value),
    _min(min),
    _max(max)
{}

void IPLProcessPropertyDouble::setValue(double value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyDouble::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyDouble::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyDouble::clone() const
{
    return new IPLProcessPropertyDouble(*this);
}


IPLProcessPropertyFloat::IPLProcessPropertyFloat(IPLProcess *process, int position, const char* name, const char* title, const char *description, float value, IPLProcessWidgetType widget, float min, float max):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value),
    _min(min),
    _max(max)
{}

void IPLProcessPropertyFloat::setValue(float value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyFloat::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyFloat::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyFloat::clone() const
{
    return new IPLProcessPropertyFloat(*this);
}


IPLProcessPropertyBool::IPLProcessPropertyBool(IPLProcess *process, int position, const char* name, const char* title, const char *description, bool value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value)
{}

void IPLProcessPropertyBool::setValue(bool value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyBool::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyBool::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyBool::clone() const
{
    return new IPLProcessPropertyBool(*this);
}

IPLProcessPropertyBoolOneShot::IPLProcessPropertyBoolOneShot(IPLProcess *process, int position, const char* name, const char* title, const char *description, bool value, IPLProcessWidgetType widget):
    IPLProcessPropertyBool(process, position,name,title,description,process,widget)
{}


IPLProcessPropertyString::IPLProcessPropertyString(IPLProcess *process, int position, const char* name, const char* title, const char *description, const std::string &value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value)
{}

void IPLProcessPropertyString::setValue(const std::string &value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

void IPLProcessPropertyString::setValue(std::string &&value)
{
    _value = std::move(value);
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyString::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyString::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyString::clone() const
{
    return new IPLProcessPropertyString(*this);
}


IPLProcessPropertyVectorInt::IPLProcessPropertyVectorInt(IPLProcess *process, int position, const char* name, const char* title, const char *description, const std::vector<int> &value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value)
{
    _default = value;
}

void IPLProcessPropertyVectorInt::setValue(const std::vector<int> &value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

void IPLProcessPropertyVectorInt::setValue(std::vector<int> &&value)
{
    _value = std::move(value);
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyVectorInt::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyVectorInt::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyVectorInt::clone() const
{
    return new IPLProcessPropertyVectorInt(*this);
}



IPLProcessPropertyVectorDouble::IPLProcessPropertyVectorDouble(IPLProcess *process, int position, const char* name, const char* title, const char *description, const std::vector<double> &value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value)
{}

void IPLProcessPropertyVectorDouble::setValue(const std::vector<double> &value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

void IPLProcessPropertyVectorDouble::setValue(std::vector<double> &&value)
{
    _value = std::move(value);
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyVectorDouble::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyVectorDouble::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyVectorDouble::clone() const
{
    return new IPLProcessPropertyVectorDouble(*this);
}


IPLProcessPropertyColor::IPLProcessPropertyColor(IPLProcess *process, int position, const char* name, const char* title, const char *description, const IPLColor &value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value)
{}

void IPLProcessPropertyColor::setValue(const IPLColor &value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

void IPLProcessPropertyColor::setValue(IPLColor &&value)
{
    _value = std::move(value);
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyColor::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyColor::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyColor::clone() const
{
    return new IPLProcessPropertyColor(*this);
}

IPLProcessPropertyPoint::IPLProcessPropertyPoint(IPLProcess *process, int position, const char* name, const char* title, const char *description, const IPLPoint &value, IPLProcessWidgetType widget):
    IPLProcessProperty(position,name,title,description,process,widget),
    _value(value),
    _default(value)
{}

void IPLProcessPropertyPoint::setValue(const IPLPoint &value)
{
    _value = value;
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

void IPLProcessPropertyPoint::setValue(IPLPoint &&value)
{
    _value = std::move(value);
    _process->requestUpdate();
    _process->processPropertyEvents(new IPLEvent(_name));
    _process->notifyPropertyChangedEventHandler();
}

IPLProcessProperty::SerializedData IPLProcessPropertyPoint::serialize() const
{
    return serializeProperty(type(),_widget,_value);
}

void IPLProcessPropertyPoint::deserialize(const SerializedData &data)
{
    deserializeProperty(data,_widget,_value);
}

IPLProcessProperty *IPLProcessPropertyPoint::clone() const
{
    return new IPLProcessPropertyPoint(*this);
}

类结构

基类 IPLProcessProperty

所有属性类的基类，定义了通用接口：

class IPLProcessProperty {
public:
    struct SerializedData {
        std::string type;
        std::string widget;
        std::string widgetName;
        std::string value;
    };
    
    // 基础信息访问
    int position() const;
    const char* name() const;
    const char* title() const;
    const char* description() const;
    IPLProcessWidgetType widget() const;
    
    // 必须实现的纯虚函数
    virtual const char* type() const = 0;
    virtual SerializedData serialize() const = 0;
    virtual void deserialize(const SerializedData &data) = 0;
    virtual IPLProcessProperty *clone() const = 0;
    virtual void resetValue() = 0;
};

派生属性类

框架提供了多种数据类型的属性类：

  1. IPLProcessPropertyInt - 整型属性

  2. IPLProcessPropertyUnsignedInt - 无符号整型属性

  3. IPLProcessPropertyDouble - 双精度浮点属性

  4. IPLProcessPropertyFloat - 单精度浮点属性

  5. IPLProcessPropertyBool - 布尔属性

  6. IPLProcessPropertyBoolOneShot - 一次性布尔属性(点击后自动复位)

  7. IPLProcessPropertyString - 字符串属性

  8. IPLProcessPropertyVectorInt - 整型向量属性

  9. IPLProcessPropertyVectorDouble - 双精度浮点向量属性

  10. IPLProcessPropertyColor - 颜色属性

  11. IPLProcessPropertyPoint - 点坐标属性

核心实现细节

序列化机制

每个属性类都实现了 serialize() 和 deserialize() 方法，用于将属性值转换为字符串表示和反向转换。

// 序列化模板函数
template<class T>
inline std::string serializeValue(const T &value) {
    std::ostringstream buffer;
    buffer << value;
    return buffer.str();
}

// 特化版本的序列化
template<>
inline std::string serializeValue<bool>(const bool &value) {
    return value ? "true" : "false";
}

// 向量类型的序列化
template<>
inline std::string serializeValue<std::vector<int>>(const std::vector<int> &value) {
    std::ostringstream buffer;
    buffer << "[";
    if (value.size() > 0) buffer << value[0];
    for (int i = 1; i < (int) value.size(); ++i) buffer << "," << value[i];
    buffer << "]";
    return buffer.str();
}

反序列化机制

反序列化使用正则表达式和 sscanf 来解析字符串值：

inline void deserializeValue(const std::string &data, bool &value) {
    std::string lowercase(data);
    std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(), tolower);
    value = (lowercase.compare("true") == 0 || lowercase.compare("1") == 0);
}

inline void deserializeValue(const std::string &data, std::vector<int> &value) {
    std::vector<int> result;
    std::smatch match;
    auto pos = data.begin();
    while(std::regex_search(pos,data.end(),match,std::regex("[0-9]|-"))) {
        pos += match.position();
        int charsParsed = 0;
        int element = 0;
        if (sscanf(&(*pos),"%d%n",&element,&charsParsed) > 0)
            result.push_back(element);
        pos += charsParsed;
    }
    value.swap(result);
}

属性变更通知

当属性值变化时，会触发以下操作：

  1. 请求处理流程更新

  2. 发送属性变化事件

  3. 通知属性变化处理器

void IPLProcessPropertyInt::setValue(int value) {
    _value = value;
    _process->requestUpdate();  // 请求更新
    _process->processPropertyEvents(new IPLEvent(_name)); // 发送事件
    _process->notifyPropertyChangedEventHandler(); // 通知处理器
}

使用示例

创建属性

// 在图像处理算法中创建属性
class MyImageProcessor : public IPLProcessor {
public:
    MyImageProcessor() {
        // 添加整型属性，范围0-100，默认值50，使用滑块控件
        addProperty("threshold", "Threshold", "Image binarization threshold", 
                    50, IPL_WIDGET_SLIDER, 0, 100);
        
        // 添加布尔属性，默认false，使用复选框
        addProperty("invert", "Invert", "Invert output", 
                    false, IPL_WIDGET_CHECKBOX);
        
        // 添加颜色属性
        addProperty("color", "Color", "Selection color", 
                    IPLColor(255,0,0), IPL_WIDGET_COLOR);
    }
};

访问属性值

void MyImageProcessor::process() {
    // 获取阈值属性值
    int threshold = getProperty("threshold")->value();
    
    // 获取反转标志
    bool invert = getProperty("invert")->value();
    
    // 获取颜色值
    IPLColor color = getProperty("color")->value();
    
    // 处理图像...
}

设计特点

  1. 类型安全：每种数据类型有对应的属性类，避免类型混淆

  2. 可扩展性：易于添加新的属性类型

  3. GUI 集成：支持多种控件类型 (滑块、复选框、颜色选择器等)

  4. 默认值支持：所有属性都保存默认值，可随时重置

  5. 克隆支持：支持深度复制属性对象

总结

IPLProcessProperty 系统是 ImagePlay 框架中处理算法参数的核心组件，它提供了:

  • 多种数据类型的属性支持

  • 完整的序列化/反序列化能力

  • 与 GUI 控件的紧密集成

  • 属性变更通知机制

  • 类型安全和可扩展的设计

这套系统使得图像处理算法的参数可以方便地在 GUI 中配置、保存和加载，大大简化了算法开发和用户交互的实现。

Qt编程：ImagePlay中IPPropertyWidget 类
倔强老吕的博客
07-17 747
IPPropertyWidget 是 ImagePlay 框架中的一个基础抽象类，用于创建属性编辑控件。它作为所有特定类型属性控件的基类，提供了与 IPLProcessProperty 交互的统一接口。
Qt编程：ImagePlay 中的IPProcessPropertiesWidget
倔强老吕的博客
07-17 903
IPProcessPropertiesWidget 是 ImagePlay 图像处理框架中负责动态生成和管理处理步骤(IPProcessStep)属性界面的核心组件。它根据不同类型的属性自动创建相应的编辑控件，并组织成统一的设置面板。
Qt编程：ImagePlay中自定义数据类型及UI实现
倔强老吕的博客
07-16 810
基于IPLProcessProperty为 ImagePlay 框架添加一个新的数据类型和对应的 Widget 实现
《使用Qt Quick从零构建AI螺丝瑕疵检测系统》——6. 传统算法实战：用OpenCV测量螺丝尺寸
最新发布
大家好，我是阿彬，专注于机器视觉中的细节之美与技术之道
07-26 636
本文介绍了如何利用OpenCV实现螺丝尺寸自动测量的视觉算法。主要内容包括：1）通过灰度转换和二值化进行图像预处理，突出目标特征；2）使用轮廓发现算法提取螺丝边界；3）计算最小外接矩形获取精确尺寸；4）将结果可视化并返回界面显示。重点讲解了cv::findContours和cv::minAreaRect等核心功能的实现方法，展示了从原始图像到几何尺寸测量的完整流程。该方案适用于工业检测中的非接触式测量场景，为后续质量判定打下基础。
Qt 与 MySQL 高级应用开发
编程与实战的博客
07-25 306
本文探讨了Qt与MySQL结合的高级应用开发，重点介绍了驱动配置、连接优化、高级查询处理、事务控制及存储过程调用等关键技术。通过代码示例展示了如何实现参数化查询防止SQL注入、批量插入优化、大结果集处理、嵌套事务和乐观锁控制等实用功能。文章还详细讲解了MySQL存储过程的调用方法，为开发高效、安全的Qt数据库应用提供了全面的技术指导。
【QT】 Qt背景介绍与概述
a_sen的博客
07-24 1306
Qt是一个跨平台的C++图形用户界面框架，支持Windows、Linux、macOS等操作系统，广泛应用于桌面应用、移动开发和嵌入式系统。自1991年推出以来，Qt经过多次迭代，目前最新版本为Qt6，但仍有许多项目使用Qt5。Qt提供商业和开源两种许可，具有开发效率高、内存管理简化等优势。其成功案例包括WPS Office、Skype、Google Earth等知名软件。随着物联网、自动驾驶和游戏开发等领域的兴起，Qt的应用前景广阔，相关技术人才需求旺盛，薪资可观。掌握Qt开发技能将为开发者带来丰富的职业发
C语言实现BIOS定义的WMI调用
Tody Guo的专栏
07-24 205
该代码展示了如何使用WMI (Windows Management Instrumentation) API与系统交互。程序首先初始化COM库和安全设置，然后通过IWbemLocator接口连接到WMI命名空间(ROOT\WMI)。接着获取TestClass类并调用其TestMethod方法，传入一个64位整型参数(0x1234)。方法执行后，程序会获取并打印返回值。整个过程涉及COM对象创建、方法调用和参数处理，最后释放所有资源并清理COM库。代码演示了典型的WMI客户端编程模式，包括错误处理和资源管理。
qt c++借助开源的.pro工程文件解读.pro文件中的各项配置的含义
随便
07-26 521
该qmake项目文件配置了QCustomPlot库的编译选项，主要包括： 依赖Qt核心模块(core/gui)，Qt5+额外依赖widgets/printsupport模块 强制启用C++11标准 通过DEFINE宏控制库的符号导出 支持同时生成debug/release版本，debug版添加"d"后缀 可编译为静态库或动态库，默认动态库 设置版本号2.1.1，影响生成文件名（Windows添加主版本号如qcustomplot2.dll） 使用合并的源文件qcustomplot.cpp/
Qt 网络编程进阶：RESTful API 调用
编程与实战的博客
07-26 78
本文介绍了使用Qt网络模块实现RESTful API调用的关键技术。通过Qt的QNetworkAccessManager类，开发者可以轻松构建GET、POST、PUT、DELETE等HTTP请求，并处理JSON格式的响应数据。文章详细展示了同步和异步请求的实现方式，包括URL参数构建、请求头设置、响应解析和错误处理。此外，还涵盖了基本认证等安全机制的实现方法，帮助开发者构建健壮的REST客户端应用。
【AI时代速通QT】第五节：Qt Creator如何引入第三方库，以OpenCV为例
攻城狮7号的博客
07-22 2882
本文详细介绍了在Qt Creator中引入OpenCV第三方库的完整流程。首先阐述了准备工作，包括获取OpenCV库文件和建立合理的项目目录结构。接着重点讲解了两种配置.pro文件的方法：图形化向导和手动编辑（推荐），特别是如何使用相对路径和条件编译区分Debug/Release模式。然后通过修改main.cpp添加简单的OpenCV测试代码验证配置。最后针对运行时常见的DLL丢失问题，提供了三种解决方案：手动复制DLL、配置Qt运行环境以及编写构建后自动拷贝脚本（推荐）。文章强调了规范的项目结构和相对路径
Qt 与 SQLite 嵌入式数据库开发
编程与实战的博客
07-25 452
Qt 与 SQLite 的结合为嵌入式数据库应用开发提供了强大而灵活的解决方案。SQLite 的轻量级特性与 Qt 的跨平台能力相得益彰，使开发者能够轻松构建高效、可靠的数据驱动应用。通过合理使用事务、索引、全文搜索等高级特性，并采用适当的性能优化策略，可以充分发挥 SQLite 在嵌入式环境中的优势。
Qt 线程池设计与实现
编程与实战的博客
07-26 345
public:线程池是 Qt 多线程编程中的重要技术，能够有效管理线程资源，提高应用性能。线程池核心组件：工作线程、任务队列和管理器线程池实现方式：从简单实现到动态调整线程数量的高级实现QtConcurrent 线程池：Qt 提供的高级线程池接口性能优化技术：无锁队列、线程亲和性设置等最佳实践：任务分割、合理配置线程池大小等在实际开发中，应根据应用的特点和需求选择合适的线程池实现方式，并通过性能测试不断优化线程池配置，以达到最佳的性能和资源利用率。
Qt 多媒体开发：音频与视频处理
编程与实战的博客
07-25 938
音频/视频播放器，支持多种格式：媒体录制器，用于录制音频或视频QCamera：摄像头访问和控制：低级别音频输入/输出：视频显示组件：播放列表管理：简单音效播放（低延迟）核心优势：跨平台支持、丰富的 API、从简单到高级的完整解决方案适用场景：媒体播放、录制、摄像头应用、音视频处理等关键组件通过合理使用 Qt 多媒体模块，可以开发出功能丰富、性能优良的跨平台音视频应用。
使用Qt下QAudioOutput播放声音
kk821521286的博客
07-23 775
如何使用QAudioOutput实现音频播放
Qt 网络编程进阶：网络安全与加密
编程与实战的博客
07-26 72
Qt 网络安全与加密技术实践 摘要：本文深入探讨了 Qt 框架中的网络安全与加密技术实现方案。主要内容包括：1) SSL/TLS 基础配置，涵盖 HTTPS 通信启用和自定义 CA 证书加载；2) 数据加密技术，重点介绍 AES 加解密实现和哈希算法应用；3) 安全认证机制，展示 OAuth2 认证流程的实现方法。文章通过具体代码示例，详细演示了 Qt 开发中如何构建安全可靠的网络应用，包括 SSL 配置优化、数据加密保护以及认证机制实现等关键技术要点。这些方案可有效提升 Qt 应用程序的网络安全性。
Qt 常用控件 - 2
Small_entreprene的博客
07-25 864
摘要：本文介绍了Qt中常用的控件属性和几何位置管理方法，重点讲解了geometry()和frameGeometry()的区别，以及如何通过setGeometry()和move()调整控件位置。文章还详细说明了窗口标题、图标的设置方法，并介绍了Qt的qrc资源管理机制，通过将资源编译到exe中实现路径无关的资源访问。最后展示了如何通过按钮控制目标控件移动的代码示例，以及如何创建"表白程序"这种交互效果。文章内容涵盖Qt界面开发中的基础控件操作和资源管理技术。
yolo--qt可视化开发
qq_25194681的博客
07-25 143
【代码】yolo--qt可视化开发。
《使用Qt Quick从零构建AI螺丝瑕疵检测系统》——3. QML入门：像搭积木一样构建UI
大家好，我是阿彬，专注于机器视觉中的细节之美与技术之道
07-23 846
本文介绍了使用Qt Quick和QML语言构建现代化用户界面的方法。首先讲解了QML的基础语法和组件结构，通过示例演示了如何创建基本UI元素并实现交互功能。随后详细介绍了布局技巧，包括使用ColumnLayout和RowLayout进行响应式设计。文章以"ScrewDetector"项目为例，展示了如何将界面划分为图像显示区、结果展示区和控制区三大功能区域，并提供了完整的QML代码实现主界面静态布局。通过属性绑定和信号处理机制，开发者可以轻松构建美观、动态的应用程序界面，同时保持前端界面
RK3568笔记九十一：QT环境搭建
07-24 87
若该文为原创文章，转载请注明原文出处。记录按照正点原子给的手册搭建QT环境参考《09【正点原子】ATK-DLRK3568_Qt开发环境搭建V1.2.pdf》
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值