添加VptElement

pansen

2019-04-11 779b80d18f41fb855bc91eb6e5470d26665e6683

添加VptElement

 QiaoJiaSystem/StructureApp/AppPipeController.cpp

@@ -19,7 +19,7 @@

//}
AppPipeController::AppPipeController(std::string folderPath, const SdkRuleMap &ruleMap) :
    m_rpcClient("RtspAnalysServer", "127.0.0.1",appPref.getIntData("RpcVTIMPort"),"tcp"),
    m_rpcClient("RtspAnalysServer", "127.0.0.1", appPref.getIntData("RpcVTIMPort"), "tcp"),
    videoCaptureElement("filePath", 25, -1, appPref.getIntData("gpu.index")),
//    videoCaptureElement(40),
    m_index(0),
@@ -69,7 +69,7 @@
//    intKeepRight();
//}
AppPipeController::AppPipeController(std::string camId, const SdkRuleMap &ruleMap, bool RecordVideoEnable) :
    m_rpcClient("RtspAnalysServer", "127.0.0.1",appPref.getIntData("RpcVTIMPort"),"tcp"),
    m_rpcClient("RtspAnalysServer", "127.0.0.1", appPref.getIntData("RpcVTIMPort"), "tcp"),
    videoCaptureElement(appPref.getStringData(camId + "rtsp"), 25, 3000, appPref.getIntData("gpu.index")),
//    videoCaptureElement(40),
    m_index(0),
@@ -256,9 +256,8 @@
    videoCaptureElement.registerConnector([&] {

        std::string imgKey;
        m_hiredisTool.listRpop(m_camId,imgKey);
        if(imgKey.empty())
        {
        m_hiredisTool.listRpop(m_camId, imgKey);
        if (imgKey.empty()) {
//            ERR("CamId  "<<m_camId<<" No ImgKey");
            return;
        }
@@ -484,6 +483,8 @@

            perimeterElement.submit();
        }
//        car
//        prc
    });
//    perimeterElement.registerConnector([&] {


 QiaoJiaSystem/StructureApp/CMakeLists.txt

@@ -44,6 +44,7 @@
    ../../../BasicPlatForm/basic/util/curl/HttpRequestWithCrul.hpp
    ../../../BasicPlatForm/basic/util/net_config/net_config.cpp
    ../../../BasicPlatForm/basic/timer_counter/Clocktimer.cpp

    )

SET(LIBS

 QiaoJiaSystem/StructureApp/VptRpcElement.cpp

New file
@@ -0,0 +1,137 @@
//
// Created by ps on 19-4-11.
//

#include <basic/util/app/AppPreference.hpp>
#include "VptRpcElement.h"

VptRpcElement::VptRpcElement(std::string shareMemoryName) : m_shareMemoryName(shareMemoryName),
                                                            m_rpcClient(appPref.getStringData("vpt.proxy"),
                                                                        appPref.getStringData("vpt.ip"),
                                                                        appPref.getIntData("vpt.port"), "tcp"),
                                                            m_sharedMemory(nullptr), m_trackingTrigger(nullptr) {

}

VptRpcElement::~VptRpcElement() {
    if (m_sharedMemory) {
        delete m_sharedMemory;
    }
    if (m_trackingTrigger) {
        delete m_trackingTrigger;
        m_trackingTrigger = nullptr;
    }
}

void VptRpcElement::setImage(const cv::Mat &value) {

    if (value.size != m_image.size) {
        m_image = cv::Mat(value.rows, value.cols, CV_8UC3, m_sharedMemory->data());
    }
    value.copyTo(m_image);
}

cv::Mat VptRpcElement::getImage() const {
    return m_image;
}

VptDetect::ObjInfos VptRpcElement::getObjects() const {
    return m_objs;
}

std::vector<ScoredRect> VptRpcElement::getLastScoreRects() const {
    return m_trackingTrigger->getLastScoreRects();
}

void VptRpcElement::threadFunc() {
    //#todo 业务
    //  ClockTimer ct("YoloRpcElement::threadFunc");
    m_triggerScoredRects.clear();
    m_CarScoredRects.clear();
    m_HPScoredRects.clear();
    m_HCPScoredRects.clear();
    try {
        auto server = m_rpcClient.getServer();
        if (!server) {
            ERR("server is null");
            return;
        }
        m_objs = server->VptDetect(m_image.cols, m_image.rows, m_sharedMemory->key().toStdString());//TODO
    }
    catch (std::exception &e) {
        ERR(e.what())
    }

    for (auto &obj: m_objs) {
        //#todo 人/人骑车/车
        if (obj.sdkDetectType != 0)
            continue;

        ScoredRect scoredRect;

        //#todo
        scoredRect.rect = cv::Rect(obj.bskRect.left, obj.bskRect.top, obj.bskRect.width, obj.bskRect.height);
        scoredRect.score = scoredRect.rect.area() > 0 ? obj.obj_score : 0;
        scoredRect.properties["time"] = getProperty("time");
        scoredRect.properties["imgKey"] = getProperty("imgKey");
        if (m_trackingTrigger->triggerOnce(scoredRect)) {
            m_trackingTrigger->getLastRect().properties["id"] = to_string(scoredRect.id);
            m_trackingTrigger->getLastRect().properties["type"] = m_TypeStr[obj.sdkDetectType];
            m_trackingTrigger->getLastRect().properties["time"] = getProperty("time");
            m_trackingTrigger->getLastRect().properties["imgKey"] = getProperty("imgKey");
            m_triggerScoredRects.push_back(m_trackingTrigger->getLastRect());
            switch (obj.sdkDetectType) {
                case 0 :
                    m_HPScoredRects.push_back(m_trackingTrigger->getLastRect());
                    break;
                case 1:
                case 2 :
                    m_HCPScoredRects.push_back(m_trackingTrigger->getLastRect());
                    break;
                case 4 :
                case 5 :
                case 6 :
                case 8 :
                    m_CarScoredRects.push_back(m_trackingTrigger->getLastRect());
                    break;
            }
        }
    }
    m_trackingTrigger->triggerLine();
    fireConnectors();
}

void VptRpcElement::init() {

    m_trackingTrigger = new TrackingTrigger(0.5);
    m_sharedMemory = new QSharedMemory(QString(m_shareMemoryName.c_str()));
//    DBG(shareMemoryName);
    //1520 x 2688   1080 x 1920 //2560 * 1440 * 4
    if (!m_sharedMemory->create(4608 * 2592 * 4)) {
        m_sharedMemory->attach();
    }

    try {
        auto server = m_rpcClient.getServer();
        m_HpResStr = server->getStr(0);      // 检测种类   case 0
        m_HcpResStr = server->getStr(1);      // 检测种类   case 1
        m_TypeStr = server->getStr(2)[0];        // 检测种类   case 2
        m_colorLabelStr = server->getStr(3)[0];    // 车牌颜色   case 3
    }
    catch (std::exception &e) {
        ERR(e.what())
    }
}

std::vector<ScoredRect> VptRpcElement::getLastHpRects() const {
    return m_HPScoredRects;
}

std::vector<ScoredRect> VptRpcElement::getLastHCPRects() const {
    return m_HCPScoredRects;
}

std::vector<ScoredRect> VptRpcElement::getLastCarRects() const {
    return m_CarScoredRects;
}


 QiaoJiaSystem/StructureApp/VptRpcElement.h

New file
@@ -0,0 +1,67 @@
//
// Created by ps on 19-4-11.
//

#ifndef QIAOJIASYSTEM_VPTRPCELEMENT_H
#define QIAOJIASYSTEM_VPTRPCELEMENT_H

#include "../VptServer/rpc/VptServer.h"
#include <basic/pipe/PipeElement.h>
#include <basic/rpc/IceRpc.hpp>
#include <opencv2/opencv.hpp>
#include <basic/util/fastdfs/FastFds.hpp>
#include <RapidStructureApp/TriggerElement.h>
#include "TrackingTrigger.h"
#include <QtCore/QSharedMemory>
#include <QtCore/QString>

#include <iostream>


class VptRpcElement : public basic::PipeElement {
public:

    VptRpcElement(std::string shareMemoryName);

    virtual ~VptRpcElement();

    void setImage(const cv::Mat &value);

    cv::Mat getImage() const;

    VptDetect::ObjInfos getObjects() const;

    std::vector<ScoredRect> getLastScoreRects() const;

    std::vector<ScoredRect> getLastHpRects() const;

    std::vector<ScoredRect> getLastHCPRects() const;

    std::vector<ScoredRect> getLastCarRects() const;

private:
    void init();

    virtual void threadFunc() override;

private:
    IceRpcClient<VptDetect::VptDetectServerPrx> m_rpcClient;
    cv::Mat m_image;
    std::string m_shareMemoryName;
    QSharedMemory *m_sharedMemory;
    ::VptDetect::ObjInfos m_objs;

    VptDetect::stringData m_TypeStr;            // 检测种类   case 2
    VptDetect::stringData m_colorLabelStr;      // 车牌颜色   case 3
    VptDetect::stringDatas m_HpResStr;          // 检测种类   case 0
    VptDetect::stringDatas m_HcpResStr;         // 检测种类   case 1
    std::vector<ScoredRect> m_triggerScoredRects;
    std::vector<ScoredRect> m_CarScoredRects;
    std::vector<ScoredRect> m_HPScoredRects;
    std::vector<ScoredRect> m_HCPScoredRects;
    TrackingTrigger *m_trackingTrigger;

};


#endif //QIAOJIASYSTEM_VPTRPCELEMENT_H

 QiaoJiaSystem/StructureApp/YoloRpcElement.cpp

@@ -10,9 +10,8 @@
    rpcClient(appPref.getStringData("yolo.proxy"), appPref.getStringData("yolo.ip"),
              appPref.getIntData("yolo.port"), "tcp"),
    sharedMemory(nullptr),
    trackingTrigger(nullptr)
{
     trackingTrigger = new TrackingTrigger(0.5);
    trackingTrigger(nullptr) {
    trackingTrigger = new TrackingTrigger(0.5);
    sharedMemory = new QSharedMemory(QString(shareMemoryName.c_str()));
//    DBG(shareMemoryName);
    //1520 x 2688   1080 x 1920 //2560 * 1440 * 4
@@ -33,22 +32,20 @@
    if (sharedMemory) {
        delete sharedMemory;
    }
    if(trackingTrigger)
    {
    if (trackingTrigger) {
        delete trackingTrigger;
        trackingTrigger=nullptr;
        trackingTrigger = nullptr;
    }
}
void YoloRpcElement::setImage(const cv::Mat &value)
{
    if (value.size != image.size)
    {

void YoloRpcElement::setImage(const cv::Mat &value) {
    if (value.size != image.size) {
        image = cv::Mat(value.rows, value.cols, CV_8UC3, sharedMemory->data());
    }
    value.copyTo(image);
}
::YoloDetect::ObjInfos YoloRpcElement::getObjects() const
{

::YoloDetect::ObjInfos YoloRpcElement::getObjects() const {
    return objs;
}

@@ -57,28 +54,24 @@
    return trackingTrigger->getLastScoreRects();
}

 cv::Mat YoloRpcElement::getImage() const
{
cv::Mat YoloRpcElement::getImage() const {
    return image;
}

void YoloRpcElement::threadFunc()
{
 //  ClockTimer ct("YoloRpcElement::threadFunc");
        triggerScoredRects.clear();
void YoloRpcElement::threadFunc() {
    //  ClockTimer ct("YoloRpcElement::threadFunc");
    triggerScoredRects.clear();
    try {
            auto server = rpcClient.getServer();
            if (!server)
            {
                ERR("server is null");
                return;
            }
            objs = server->YoloDetect(image.cols, image.rows, sharedMemory->key().toStdString());//TODO
        auto server = rpcClient.getServer();
        if (!server) {
            ERR("server is null");
            return;
        }
        catch (std::exception &e)
        {
            ERR(e.what())
        }
        objs = server->YoloDetect(image.cols, image.rows, sharedMemory->key().toStdString());//TODO
    }
    catch (std::exception &e) {
        ERR(e.what())
    }
//        int size=objs.size();
//        if(size>30)
//        {
@@ -87,37 +80,35 @@
//            return;
//        }

        for (auto &obj: objs)
        {
            if (obj.type != 0)
                continue;
    for (auto &obj: objs) {
        if (obj.type != 0)
            continue;

            ScoredRect scoredRect;
        ScoredRect scoredRect;

            int x = obj.rcObj.left * image.cols;
            int y = obj.rcObj.top * image.rows;
            int w = (obj.rcObj.right - obj.rcObj.left) * image.cols;
            int h = (obj.rcObj.bottom - obj.rcObj.top) * image.rows;
            scoredRect.rect = cv::Rect(x, y, w, h);
            scoredRect.score = scoredRect.rect.area() > 0 ? obj.prob : 0;
            scoredRect.properties["time"] = getProperty("time");
            scoredRect.properties["imgKey"]=getProperty("imgKey");
            if (trackingTrigger->triggerOnce(scoredRect))
            {
                trackingTrigger->getLastRect().properties["id"] = to_string(scoredRect.id);
                trackingTrigger->getLastRect().properties["type"] = cocoData[obj.type];
                trackingTrigger->getLastRect().properties["time"] = getProperty("time");
                trackingTrigger->getLastRect().properties["imgKey"]=getProperty("imgKey");
              //  DBG("time)"<<getProperty("time"));
                triggerScoredRects.push_back(trackingTrigger->getLastRect());
            }
        int x = obj.rcObj.left * image.cols;
        int y = obj.rcObj.top * image.rows;
        int w = (obj.rcObj.right - obj.rcObj.left) * image.cols;
        int h = (obj.rcObj.bottom - obj.rcObj.top) * image.rows;
        scoredRect.rect = cv::Rect(x, y, w, h);
        scoredRect.score = scoredRect.rect.area() > 0 ? obj.prob : 0;
        scoredRect.properties["time"] = getProperty("time");
        scoredRect.properties["imgKey"] = getProperty("imgKey");
        if (trackingTrigger->triggerOnce(scoredRect)) {
            trackingTrigger->getLastRect().properties["id"] = to_string(scoredRect.id);
            trackingTrigger->getLastRect().properties["type"] = cocoData[obj.type];
            trackingTrigger->getLastRect().properties["time"] = getProperty("time");
            trackingTrigger->getLastRect().properties["imgKey"] = getProperty("imgKey");
            //  DBG("time)"<<getProperty("time"));
            triggerScoredRects.push_back(trackingTrigger->getLastRect());
        }
        trackingTrigger->triggerLine();
    }
    trackingTrigger->triggerLine();
//        if(trackingTrigger->getLastScoreRects().size()>20)
//        {
//            DBG("");
//        }
        fireConnectors();
    fireConnectors();
}



 QiaoJiaSystem/VideoAnalysFromHC/CMakeLists.txt

@@ -61,7 +61,9 @@
    ../StructureApp/PersonElement.cpp
    ../StructureApp/PerStaticElement.cpp
    ../StructureApp/IntAreaCalcUtil.cpp
    ../StructureApp/VptRpcElement.cpp

    ../VptServer/rpc/VptServer.cpp
    ../YoloServer/rpc/YoloServer.cpp
    ../FaceDetectServer/rpc/FaceServer.cpp
    ../FaceSearchServer/rpc/FaceSearchServer.cpp
@@ -182,6 +184,7 @@
    ../VideoServer/QiaoJia/DB
    ../VideoServer/QiaoJia/dispatchTool

    ../VptServer/rpc
    ../RecordVideo/rpc
    ../StructureApp/rpc
    ../YoloServer/rpc

 QiaoJiaSystem/VptServer/VptDetectWrapper.cpp

@@ -79,7 +79,15 @@
            m_results.emplace_back(std::move(changeAnalysisRes(colorIndex, result.info[i].analysis_res)));
            m_results.back().bskRect.setRect(result.info[i].obj_rect.left_, result.info[i].obj_rect.top_,
                                             result.info[i].obj_rect.width_, result.info[i].obj_rect.height_);
        } else {}
            m_results.back().obj_score = result.info[i].obj_score;
        } else {
            VptDetectResults vptDetectResults;
            vptDetectResults.sdkDetectType = static_cast<SDKDetectType>(colorIndex);
            vptDetectResults.bskRect.setRect(result.info[i].obj_rect.left_, result.info[i].obj_rect.top_,
                                             result.info[i].obj_rect.width_, result.info[i].obj_rect.height_);
            vptDetectResults.obj_score = result.info[i].obj_score;
            m_results.emplace_back(vptDetectResults);
        }
    }
    //release source
    if (result.info != NULL) {

 QiaoJiaSystem/VptServer/VptDetectWrapper.h

@@ -183,6 +183,7 @@

        this->sdkDetectType = src.sdkDetectType;
        this->bskRect = src.bskRect;
        this->obj_score = src.obj_score;

        switch (src.sdkDetectType) {
            case SDKDetectType::person :
@@ -201,6 +202,7 @@
        }
    }

    float obj_score;
    VPTDetectRes vptDetectRes;
    SDKDetectType sdkDetectType;
    BskRect bskRect;

 QiaoJiaSystem/VptServer/VptServerI.cpp

@@ -39,6 +39,7 @@
            ::VptDetect::VptDetectResult vptDetectResult;

            vptDetectResult.sdkDetectType = static_cast<Ice::Int>(item.sdkDetectType);
            vptDetectResult.obj_score = item.obj_score;

            vptDetectResult.bskRect.left = item.bskRect.left_;
            vptDetectResult.bskRect.top = item.bskRect.top_;

 QiaoJiaSystem/VptServer/demo.cpp

@@ -71,7 +71,10 @@
        process_image.copyTo(image);

        auto res = server->VptDetect(image.cols, image.rows, sharedMemory->key().toStdString());
        DBG(res.size());
        if (res.size() > 0) {

            DBG(res.size());
        }

//        for (int i = 0; i < result.count; i++) {
//            char str_i[100];

 QiaoJiaSystem/VptServer/main.cpp

@@ -30,7 +30,6 @@
#define printExp(exp) cout<<#exp<<"为:\t\t"<<(exp)<<endl
#define printExpToString(exp) cout<<(string(#exp)+"为:\t\t")<<(exp).toString()<<endl //注意exp加括号更安全


int main(int argc, char **argv) {

    std::cout << __DATE__ << " " << __TIME__ << std::endl;
@@ -44,7 +43,6 @@
    appPref.setIntData("gpu.index", atoi(argv[1]));
    appPref.setIntData("RpcVptPort", atoi(argv[2]));
    appPref.setFloatData("thresh.detect", atof(argv[3]));


    IceRpcServer<VptServerI> server("vptServer", appPref.getIntData("RpcVptPort"), "tcp");
    server.setMessageSizeMax(1024 * 1024 * 50);

 QiaoJiaSystem/VptServer/rpc/VptServer.h

@@ -135,14 +135,15 @@
struct VptDetectResult
{
    int sdkDetectType;
    float obj_score;
    ::VptDetect::RECT bskRect;
    ::VptDetect::PersonDetectRes personDetectRes;
    ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
    ::VptDetect::CarDetectRes carDetectRes;

    std::tuple<const int&, const ::VptDetect::RECT&, const ::VptDetect::PersonDetectRes&, const ::VptDetect::PerRideCarDetectRes&, const ::VptDetect::CarDetectRes&> ice_tuple() const
    std::tuple<const int&, const float&, const ::VptDetect::RECT&, const ::VptDetect::PersonDetectRes&, const ::VptDetect::PerRideCarDetectRes&, const ::VptDetect::CarDetectRes&> ice_tuple() const
    {
        return std::tie(sdkDetectType, bskRect, personDetectRes, perRideCarDetectRes, carDetectRes);
        return std::tie(sdkDetectType, obj_score, bskRect, personDetectRes, perRideCarDetectRes, carDetectRes);
    }
};

@@ -450,7 +451,7 @@
struct StreamableTraits<::VptDetect::VptDetectResult>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 68;
    static const int minWireSize = 72;
    static const bool fixedLength = false;
};

@@ -459,7 +460,7 @@
{
    static void read(S* istr, ::VptDetect::VptDetectResult& v)
    {
        istr->readAll(v.sdkDetectType, v.bskRect, v.personDetectRes, v.perRideCarDetectRes, v.carDetectRes);
        istr->readAll(v.sdkDetectType, v.obj_score, v.bskRect, v.personDetectRes, v.perRideCarDetectRes, v.carDetectRes);
    }
};

@@ -475,1275 +476,1257 @@

#else // C++98 mapping

namespace IceProxy {
namespace IceProxy
{

    namespace VptDetect {
namespace VptDetect
{

        class VptDetectServer;

        void _readProxy(::Ice::InputStream *, ::IceInternal::ProxyHandle<::IceProxy::VptDetect::VptDetectServer> &);

        ::IceProxy::Ice::Object *upCast(::IceProxy::VptDetect::VptDetectServer *);

    }
class VptDetectServer;
void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::VptDetect::VptDetectServer>&);
::IceProxy::Ice::Object* upCast(::IceProxy::VptDetect::VptDetectServer*);

}

namespace VptDetect {
}

    class VptDetectServer;
namespace VptDetect
{

    ::Ice::Object *upCast(::VptDetect::VptDetectServer *);

    typedef ::IceInternal::Handle<::VptDetect::VptDetectServer> VptDetectServerPtr;
    typedef ::IceInternal::ProxyHandle<::IceProxy::VptDetect::VptDetectServer> VptDetectServerPrx;
    typedef VptDetectServerPrx VptDetectServerPrxPtr;

    void _icePatchObjectPtr(VptDetectServerPtr &, const ::Ice::ObjectPtr &);
class VptDetectServer;
::Ice::Object* upCast(::VptDetect::VptDetectServer*);
typedef ::IceInternal::Handle< ::VptDetect::VptDetectServer> VptDetectServerPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::VptDetect::VptDetectServer> VptDetectServerPrx;
typedef VptDetectServerPrx VptDetectServerPrxPtr;
void _icePatchObjectPtr(VptDetectServerPtr&, const ::Ice::ObjectPtr&);

}

namespace VptDetect {
namespace VptDetect
{

    struct RECT {
        ::Ice::Float left;
        ::Ice::Float top;
        ::Ice::Float width;
        ::Ice::Float height;
    };
struct RECT
{
    ::Ice::Float left;
    ::Ice::Float top;
    ::Ice::Float width;
    ::Ice::Float height;
};

    struct ClassfyObjRes {
        ::Ice::Int res_index;
        ::Ice::Float res_prob;
    };
struct ClassfyObjRes
{
    ::Ice::Int res_index;
    ::Ice::Float res_prob;
};

    typedef ::std::vector<::VptDetect::ClassfyObjRes> ResObjs;
typedef ::std::vector< ::VptDetect::ClassfyObjRes> ResObjs;

    struct PersonDetectRes {
        ::VptDetect::ResObjs res_objs;
    };
struct PersonDetectRes
{
    ::VptDetect::ResObjs res_objs;
};

    struct PerRideCarDetectRes {
        ::VptDetect::ResObjs res_objs;
    };
struct PerRideCarDetectRes
{
    ::VptDetect::ResObjs res_objs;
};

    struct CarDetectRes {
        ::std::string vehicle_brand;
        ::std::string vehicle_subbrand;
        ::std::string vehicle_issue_year;
        ::std::string vehicle_type;
        ::std::string freight_ton;
        ::Ice::Float vehicle_score;
        ::Ice::Int colorLabel;
        ::Ice::Float colorLabelProb;
        ::VptDetect::RECT carPlateRect;
        ::Ice::Float carPlateRectScore;
        ::std::string carPlate;
        ::Ice::Float carPlateScore;
        ::Ice::Int carPlatetype;
    };
struct CarDetectRes
{
    ::std::string vehicle_brand;
    ::std::string vehicle_subbrand;
    ::std::string vehicle_issue_year;
    ::std::string vehicle_type;
    ::std::string freight_ton;
    ::Ice::Float vehicle_score;
    ::Ice::Int colorLabel;
    ::Ice::Float colorLabelProb;
    ::VptDetect::RECT carPlateRect;
    ::Ice::Float carPlateRectScore;
    ::std::string carPlate;
    ::Ice::Float carPlateScore;
    ::Ice::Int carPlatetype;
};

    struct VptDetectResult {
        ::Ice::Int sdkDetectType;
        ::VptDetect::RECT bskRect;
        ::VptDetect::PersonDetectRes personDetectRes;
        ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
        ::VptDetect::CarDetectRes carDetectRes;
    };
struct VptDetectResult
{
    ::Ice::Int sdkDetectType;
    ::Ice::Float obj_score;
    ::VptDetect::RECT bskRect;
    ::VptDetect::PersonDetectRes personDetectRes;
    ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
    ::VptDetect::CarDetectRes carDetectRes;
};

    typedef ::std::vector<::VptDetect::VptDetectResult> ObjInfos;
typedef ::std::vector< ::VptDetect::VptDetectResult> ObjInfos;

    typedef ::std::vector<::std::string> stringData;
typedef ::std::vector< ::std::string> stringData;

    typedef ::std::vector<::VptDetect::stringData> stringDatas;
typedef ::std::vector< ::VptDetect::stringData> stringDatas;

}

namespace VptDetect {
namespace VptDetect
{

    class Callback_VptDetectServer_VptDetect_Base : public virtual ::IceInternal::CallbackBase {
    };
class Callback_VptDetectServer_VptDetect_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;

    typedef ::IceUtil::Handle<Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;
class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;

    class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase {
    };
class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getTypeStr_Base> Callback_VptDetectServer_getTypeStrPtr;

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;
class Callback_VptDetectServer_getColorLabel_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;

    class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase {
    };
class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getTypeStr_Base> Callback_VptDetectServer_getTypeStrPtr;

    class Callback_VptDetectServer_getColorLabel_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;

    class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;

    class Callback_VptDetectServer_getHcpResStr_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getHcpResStr_Base> Callback_VptDetectServer_getHcpResStrPtr;
class Callback_VptDetectServer_getHcpResStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHcpResStr_Base> Callback_VptDetectServer_getHcpResStrPtr;

}

namespace IceProxy {
namespace IceProxy
{

    namespace VptDetect {
namespace VptDetect
{

        class VptDetectServer : public virtual ::Ice::Proxy<VptDetectServer, ::IceProxy::Ice::Object> {
        public:
class VptDetectServer : public virtual ::Ice::Proxy<VptDetectServer, ::IceProxy::Ice::Object>
{
public:

            ::VptDetect::ObjInfos
            VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                      const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_VptDetect(_iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context,
                                                           ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context,
                                             ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del,
                                             cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::VptDetect::Callback_VptDetectServer_VptDetectPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del,
                                             cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context,
                            const ::VptDetect::Callback_VptDetectServer_VptDetectPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
            }

            ::VptDetect::ObjInfos end_VptDetect(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Context &,
                                  const ::IceInternal::CallbackBasePtr &, const ::Ice::LocalObjectPtr &cookie = 0,
                                  bool sync = false);

        public:

            ::VptDetect::stringDatas
            getStr(::Ice::Int iceP_type, const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getStr(_iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                         const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, context, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::VptDetect::Callback_VptDetectServer_getStrPtr &del,
                         const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context,
                                               const ::VptDetect::Callback_VptDetectServer_getStrPtr &del,
                                               const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, context, del, cookie);
            }

            ::VptDetect::stringDatas end_getStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getStr(::Ice::Int, const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                               const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringData getTypeStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getTypeStr(_iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getTypeStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context,
                                                   const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(context, del, cookie);
            }

            ::VptDetect::stringData end_getTypeStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr _iceI_begin_getTypeStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                                         const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringData getColorLabel(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getColorLabel(_iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getColorLabel(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context,
                                                      const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(context, del, cookie);
            }

            ::VptDetect::stringData end_getColorLabel(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getColorLabel(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                      const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringDatas getHpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getHpResStr(_iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getHpResStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context,
                                                    const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(context, del, cookie);
            }

            ::VptDetect::stringDatas end_getHpResStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getHpResStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                    const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringDatas getHcpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getHcpResStr(_iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getHcpResStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context,
                                                     const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(context, del, cookie);
            }

            ::VptDetect::stringDatas end_getHcpResStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getHcpResStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                     const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            static const ::std::string &ice_staticId();

        protected:

            virtual ::IceProxy::Ice::Object *_newInstance() const;
        };

    ::VptDetect::ObjInfos VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_VptDetect(_iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::VptDetect::Callback_VptDetectServer_VptDetectPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_VptDetectPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
    }

    ::VptDetect::ObjInfos end_VptDetect(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_VptDetect(::Ice::Int, ::Ice::Int, const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getStr(::Ice::Int iceP_type, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getStr(_iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::VptDetect::Callback_VptDetectServer_getStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, context, del, cookie);
    }

    ::VptDetect::stringDatas end_getStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getStr(::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringData getTypeStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getTypeStr(_iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(context, del, cookie);
    }

    ::VptDetect::stringData end_getTypeStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getTypeStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringData getColorLabel(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getColorLabel(_iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(context, del, cookie);
    }

    ::VptDetect::stringData end_getColorLabel(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getColorLabel(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getHpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getHpResStr(_iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(context, del, cookie);
    }

    ::VptDetect::stringDatas end_getHpResStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getHpResStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getHcpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getHcpResStr(_iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(context, del, cookie);
    }

    ::VptDetect::stringDatas end_getHcpResStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getHcpResStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    static const ::std::string& ice_staticId();

protected:

    virtual ::IceProxy::Ice::Object* _newInstance() const;
};

}

namespace VptDetect {
}

    class VptDetectServer : public virtual ::Ice::Object {
    public:
namespace VptDetect
{

        typedef VptDetectServerPrx ProxyType;
        typedef VptDetectServerPtr PointerType;
class VptDetectServer : public virtual ::Ice::Object
{
public:

        virtual ~VptDetectServer();
    typedef VptDetectServerPrx ProxyType;
    typedef VptDetectServerPtr PointerType;

        virtual bool ice_isA(const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) const;
    virtual ~VptDetectServer();

        virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current & = ::Ice::emptyCurrent) const;
    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const;

        virtual const ::std::string &ice_id(const ::Ice::Current & = ::Ice::emptyCurrent) const;
    static const ::std::string& ice_staticId();

        static const ::std::string &ice_staticId();
    virtual ::VptDetect::ObjInfos VptDetect(::Ice::Int, ::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_VptDetect(::IceInternal::Incoming&, const ::Ice::Current&);

        virtual ::VptDetect::ObjInfos
        VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
    virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getStr(::IceInternal::Incoming&, const ::Ice::Current&);

        bool _iceD_VptDetect(::IceInternal::Incoming &, const ::Ice::Current &);
    virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getTypeStr(::IceInternal::Incoming&, const ::Ice::Current&);

        virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
    virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getColorLabel(::IceInternal::Incoming&, const ::Ice::Current&);

        bool _iceD_getStr(::IceInternal::Incoming &, const ::Ice::Current &);
    virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getHpResStr(::IceInternal::Incoming&, const ::Ice::Current&);

        virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
    virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getHcpResStr(::IceInternal::Incoming&, const ::Ice::Current&);

        bool _iceD_getTypeStr(::IceInternal::Incoming &, const ::Ice::Current &);
    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);

        virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
protected:

        bool _iceD_getColorLabel(::IceInternal::Incoming &, const ::Ice::Current &);
    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
    virtual void _iceReadImpl(::Ice::InputStream*);
};

        virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
inline bool operator==(const VptDetectServer& lhs, const VptDetectServer& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}

        bool _iceD_getHpResStr(::IceInternal::Incoming &, const ::Ice::Current &);

        virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

        bool _iceD_getHcpResStr(::IceInternal::Incoming &, const ::Ice::Current &);

        virtual bool _iceDispatch(::IceInternal::Incoming &, const ::Ice::Current &);

    protected:

        virtual void _iceWriteImpl(::Ice::OutputStream *) const;

        virtual void _iceReadImpl(::Ice::InputStream *);
    };

    inline bool operator==(const VptDetectServer &lhs, const VptDetectServer &rhs) {
        return static_cast<const ::Ice::Object &>(lhs) == static_cast<const ::Ice::Object &>(rhs);
    }

    inline bool operator<(const VptDetectServer &lhs, const VptDetectServer &rhs) {
        return static_cast<const ::Ice::Object &>(lhs) < static_cast<const ::Ice::Object &>(rhs);
    }
inline bool operator<(const VptDetectServer& lhs, const VptDetectServer& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}

}

namespace Ice {
namespace Ice
{

    template<>
    struct StreamableTraits<::VptDetect::RECT> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 16;
        static const bool fixedLength = true;
    };
template<>
struct StreamableTraits< ::VptDetect::RECT>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 16;
    static const bool fixedLength = true;
};

    template<typename S>
    struct StreamWriter<::VptDetect::RECT, S> {
        static void write(S *ostr, const ::VptDetect::RECT &v) {
            ostr->write(v.left);
            ostr->write(v.top);
            ostr->write(v.width);
            ostr->write(v.height);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::RECT, S>
{
    static void write(S* ostr, const ::VptDetect::RECT& v)
    {
        ostr->write(v.left);
        ostr->write(v.top);
        ostr->write(v.width);
        ostr->write(v.height);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::RECT, S> {
        static void read(S *istr, ::VptDetect::RECT &v) {
            istr->read(v.left);
            istr->read(v.top);
            istr->read(v.width);
            istr->read(v.height);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::RECT, S>
{
    static void read(S* istr, ::VptDetect::RECT& v)
    {
        istr->read(v.left);
        istr->read(v.top);
        istr->read(v.width);
        istr->read(v.height);
    }
};

    template<>
    struct StreamableTraits<::VptDetect::ClassfyObjRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 8;
        static const bool fixedLength = true;
    };
template<>
struct StreamableTraits< ::VptDetect::ClassfyObjRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 8;
    static const bool fixedLength = true;
};

    template<typename S>
    struct StreamWriter<::VptDetect::ClassfyObjRes, S> {
        static void write(S *ostr, const ::VptDetect::ClassfyObjRes &v) {
            ostr->write(v.res_index);
            ostr->write(v.res_prob);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::ClassfyObjRes, S>
{
    static void write(S* ostr, const ::VptDetect::ClassfyObjRes& v)
    {
        ostr->write(v.res_index);
        ostr->write(v.res_prob);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::ClassfyObjRes, S> {
        static void read(S *istr, ::VptDetect::ClassfyObjRes &v) {
            istr->read(v.res_index);
            istr->read(v.res_prob);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::ClassfyObjRes, S>
{
    static void read(S* istr, ::VptDetect::ClassfyObjRes& v)
    {
        istr->read(v.res_index);
        istr->read(v.res_prob);
    }
};

    template<>
    struct StreamableTraits<::VptDetect::PersonDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
template<>
struct StreamableTraits< ::VptDetect::PersonDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 1;
    static const bool fixedLength = false;
};

    template<typename S>
    struct StreamWriter<::VptDetect::PersonDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::PersonDetectRes &v) {
            ostr->write(v.res_objs);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::PersonDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::PersonDetectRes& v)
    {
        ostr->write(v.res_objs);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::PersonDetectRes, S> {
        static void read(S *istr, ::VptDetect::PersonDetectRes &v) {
            istr->read(v.res_objs);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::PersonDetectRes, S>
{
    static void read(S* istr, ::VptDetect::PersonDetectRes& v)
    {
        istr->read(v.res_objs);
    }
};

    template<>
    struct StreamableTraits<::VptDetect::PerRideCarDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
template<>
struct StreamableTraits< ::VptDetect::PerRideCarDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 1;
    static const bool fixedLength = false;
};

    template<typename S>
    struct StreamWriter<::VptDetect::PerRideCarDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::PerRideCarDetectRes &v) {
            ostr->write(v.res_objs);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::PerRideCarDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::PerRideCarDetectRes& v)
    {
        ostr->write(v.res_objs);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::PerRideCarDetectRes, S> {
        static void read(S *istr, ::VptDetect::PerRideCarDetectRes &v) {
            istr->read(v.res_objs);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::PerRideCarDetectRes, S>
{
    static void read(S* istr, ::VptDetect::PerRideCarDetectRes& v)
    {
        istr->read(v.res_objs);
    }
};

    template<>
    struct StreamableTraits<::VptDetect::CarDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 46;
        static const bool fixedLength = false;
    };
template<>
struct StreamableTraits< ::VptDetect::CarDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 46;
    static const bool fixedLength = false;
};

    template<typename S>
    struct StreamWriter<::VptDetect::CarDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::CarDetectRes &v) {
            ostr->write(v.vehicle_brand);
            ostr->write(v.vehicle_subbrand);
            ostr->write(v.vehicle_issue_year);
            ostr->write(v.vehicle_type);
            ostr->write(v.freight_ton);
            ostr->write(v.vehicle_score);
            ostr->write(v.colorLabel);
            ostr->write(v.colorLabelProb);
            ostr->write(v.carPlateRect);
            ostr->write(v.carPlateRectScore);
            ostr->write(v.carPlate);
            ostr->write(v.carPlateScore);
            ostr->write(v.carPlatetype);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::CarDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::CarDetectRes& v)
    {
        ostr->write(v.vehicle_brand);
        ostr->write(v.vehicle_subbrand);
        ostr->write(v.vehicle_issue_year);
        ostr->write(v.vehicle_type);
        ostr->write(v.freight_ton);
        ostr->write(v.vehicle_score);
        ostr->write(v.colorLabel);
        ostr->write(v.colorLabelProb);
        ostr->write(v.carPlateRect);
        ostr->write(v.carPlateRectScore);
        ostr->write(v.carPlate);
        ostr->write(v.carPlateScore);
        ostr->write(v.carPlatetype);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::CarDetectRes, S> {
        static void read(S *istr, ::VptDetect::CarDetectRes &v) {
            istr->read(v.vehicle_brand);
            istr->read(v.vehicle_subbrand);
            istr->read(v.vehicle_issue_year);
            istr->read(v.vehicle_type);
            istr->read(v.freight_ton);
            istr->read(v.vehicle_score);
            istr->read(v.colorLabel);
            istr->read(v.colorLabelProb);
            istr->read(v.carPlateRect);
            istr->read(v.carPlateRectScore);
            istr->read(v.carPlate);
            istr->read(v.carPlateScore);
            istr->read(v.carPlatetype);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::CarDetectRes, S>
{
    static void read(S* istr, ::VptDetect::CarDetectRes& v)
    {
        istr->read(v.vehicle_brand);
        istr->read(v.vehicle_subbrand);
        istr->read(v.vehicle_issue_year);
        istr->read(v.vehicle_type);
        istr->read(v.freight_ton);
        istr->read(v.vehicle_score);
        istr->read(v.colorLabel);
        istr->read(v.colorLabelProb);
        istr->read(v.carPlateRect);
        istr->read(v.carPlateRectScore);
        istr->read(v.carPlate);
        istr->read(v.carPlateScore);
        istr->read(v.carPlatetype);
    }
};

    template<>
    struct StreamableTraits<::VptDetect::VptDetectResult> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 68;
        static const bool fixedLength = false;
    };
template<>
struct StreamableTraits< ::VptDetect::VptDetectResult>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 72;
    static const bool fixedLength = false;
};

    template<typename S>
    struct StreamWriter<::VptDetect::VptDetectResult, S> {
        static void write(S *ostr, const ::VptDetect::VptDetectResult &v) {
            ostr->write(v.sdkDetectType);
            ostr->write(v.bskRect);
            ostr->write(v.personDetectRes);
            ostr->write(v.perRideCarDetectRes);
            ostr->write(v.carDetectRes);
        }
    };
template<typename S>
struct StreamWriter< ::VptDetect::VptDetectResult, S>
{
    static void write(S* ostr, const ::VptDetect::VptDetectResult& v)
    {
        ostr->write(v.sdkDetectType);
        ostr->write(v.obj_score);
        ostr->write(v.bskRect);
        ostr->write(v.personDetectRes);
        ostr->write(v.perRideCarDetectRes);
        ostr->write(v.carDetectRes);
    }
};

    template<typename S>
    struct StreamReader<::VptDetect::VptDetectResult, S> {
        static void read(S *istr, ::VptDetect::VptDetectResult &v) {
            istr->read(v.sdkDetectType);
            istr->read(v.bskRect);
            istr->read(v.personDetectRes);
            istr->read(v.perRideCarDetectRes);
            istr->read(v.carDetectRes);
        }
    };
template<typename S>
struct StreamReader< ::VptDetect::VptDetectResult, S>
{
    static void read(S* istr, ::VptDetect::VptDetectResult& v)
    {
        istr->read(v.sdkDetectType);
        istr->read(v.obj_score);
        istr->read(v.bskRect);
        istr->read(v.personDetectRes);
        istr->read(v.perRideCarDetectRes);
        istr->read(v.carDetectRes);
    }
};

}

namespace VptDetect {
namespace VptDetect
{

    template<class T>
    class CallbackNC_VptDetectServer_VptDetect
        : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:
template<class T>
class CallbackNC_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

        typedef IceUtil::Handle<T> TPtr;
    typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);
    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::ObjInfos&);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::ObjInfos &);

        CallbackNC_VptDetectServer_VptDetect(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::ObjInfos ret;
            try {
                ret = proxy->end_VptDetect(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T> &instance,
                                          void (T::*cb)(const ::VptDetect::ObjInfos &),
                                          void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
    CallbackNC_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    template<class T>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(T *instance, void (T::*cb)(const ::VptDetect::ObjInfos &),
                                          void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_VptDetect
        : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::ObjInfos &, const CT &);

        Callback_VptDetectServer_VptDetect(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::ObjInfos ret;
        try
        {
            ret = proxy->end_VptDetect(result);
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::ObjInfos ret;
            try {
                ret = proxy->end_VptDetect(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T> &instance,
                                          void (T::*cb)(const ::VptDetect::ObjInfos &, const CT &),
                                          void (T::*excb)(const ::Ice::Exception &, const CT &),
                                          void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(T *instance, void (T::*cb)(const ::VptDetect::ObjInfos &, const CT &),
                                          void (T::*excb)(const ::Ice::Exception &, const CT &),
                                          void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T>
    class CallbackNC_VptDetectServer_getStr
        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

        CallbackNC_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
private:

    Response _response;
};

template<class T> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::ObjInfos&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(T* instance, void (T::*cb)(const ::VptDetect::ObjInfos&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::ObjInfos&, const CT&);

    Callback_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::ObjInfos ret;
        try
        {
            ret = proxy->end_VptDetect(result);
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(const IceUtil::Handle<T> &instance,
                                       void (T::*cb)(const ::VptDetect::stringDatas &),
                                       void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
    }

    template<class T>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                       void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_getStr
        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

        Callback_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(const IceUtil::Handle<T> &instance,
                                       void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                       void (T::*excb)(const ::Ice::Exception &, const CT &),
                                       void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                       void (T::*excb)(const ::Ice::Exception &, const CT &),
                                       void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::ObjInfos&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(T* instance, void (T::*cb)(const ::VptDetect::ObjInfos&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);

    CallbackNC_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    template<class T>
    class CallbackNC_VptDetectServer_getTypeStr
        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::stringData &);

        CallbackNC_VptDetectServer_getTypeStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getStr(result);
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getTypeStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T> &instance,
                                           void (T::*cb)(const ::VptDetect::stringData &),
                                           void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
    }

    template<class T>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(T *instance, void (T::*cb)(const ::VptDetect::stringData &),
                                           void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_getTypeStr
        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::stringData &, const CT &);

        Callback_VptDetectServer_getTypeStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getTypeStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
private:

    Response _response;
};

template<class T> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);

    Callback_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getStr(result);
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T> &instance,
                                           void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                           void (T::*excb)(const ::Ice::Exception &, const CT &),
                                           void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(T *instance, void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                           void (T::*excb)(const ::Ice::Exception &, const CT &),
                                           void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T>
    class CallbackNC_VptDetectServer_getColorLabel
        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::stringData &);

        CallbackNC_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getColorLabel(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T> &instance,
                                              void (T::*cb)(const ::VptDetect::stringData &),
                                              void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
    }

    template<class T>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(T *instance, void (T::*cb)(const ::VptDetect::stringData &),
                                              void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringData&);

    CallbackNC_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_getColorLabel
        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::stringData &, const CT &);

        Callback_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getTypeStr(result);
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getColorLabel(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T> &instance,
                                              void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                              void (T::*excb)(const ::Ice::Exception &, const CT &),
                                              void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(T *instance, void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                              void (T::*excb)(const ::Ice::Exception &, const CT &),
                                              void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T>
    class CallbackNC_VptDetectServer_getHpResStr
        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

        CallbackNC_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
private:

    Response _response;
};

template<class T> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(T* instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringData&, const CT&);

    Callback_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getTypeStr(result);
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T> &instance,
                                            void (T::*cb)(const ::VptDetect::stringDatas &),
                                            void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
    }

    template<class T>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                            void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_getHpResStr
        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

        Callback_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T> &instance,
                                            void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                            void (T::*excb)(const ::Ice::Exception &, const CT &),
                                            void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                            void (T::*excb)(const ::Ice::Exception &, const CT &),
                                            void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(T* instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringData&);

    CallbackNC_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    template<class T>
    class CallbackNC_VptDetectServer_getHcpResStr
        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &);

        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

        CallbackNC_VptDetectServer_getHcpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getColorLabel(result);
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHcpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T> &instance,
                                             void (T::*cb)(const ::VptDetect::stringDatas &),
                                             void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
    }

    template<class T>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                             void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
    }

    template<class T, typename CT>
    class Callback_VptDetectServer_getHcpResStr
        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

        typedef IceUtil::Handle<T> TPtr;

        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

        typedef void (T::*Sent)(bool, const CT &);

        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

        Callback_VptDetectServer_getHcpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHcpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
private:

    Response _response;
};

template<class T> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(T* instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringData&, const CT&);

    Callback_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getColorLabel(result);
        }

    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T> &instance,
                                             void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                             void (T::*excb)(const ::Ice::Exception &, const CT &),
                                             void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    }

    template<class T, typename CT>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                             void (T::*excb)(const ::Ice::Exception &, const CT &),
                                             void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(T* instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);

    CallbackNC_VptDetectServer_getHpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

private:

    Response _response;
};

template<class T> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);

    Callback_VptDetectServer_getHpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    }

private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);

    CallbackNC_VptDetectServer_getHcpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHcpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    }

private:

    Response _response;
};

template<class T> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);

    Callback_VptDetectServer_getHcpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHcpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    }

private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
}

}

#endif

#include <IceUtil/PopDisableWarnings.h>

#endif

 QiaoJiaSystem/VptServer/rpc/VptServer.ice

@@ -45,6 +45,7 @@

    struct VptDetectResult {
        int sdkDetectType;
        float obj_score;                            //检测置信度
        RECT bskRect;
        PersonDetectRes personDetectRes;
        PerRideCarDetectRes perRideCarDetectRes;

 QiaoJiaSystem/VptServer/rpc/gen.sh

@@ -1,2 +1,2 @@
#!/usr/bin/env bash
./../../../BasicPlatForm/libs/Ice-3.7.0/bin/slice2cpp VptServer.ice
./../../../../BasicPlatForm/libs/Ice-3.7.0/bin/slice2cpp VptServer.ice