From 779b80d18f41fb855bc91eb6e5470d26665e6683 Mon Sep 17 00:00:00 2001
From: pansen <pansen626@sina.com>
Date: 星期四, 11 四月 2019 15:36:32 +0800
Subject: [PATCH] 添加VptElement

---
 QiaoJiaSystem/VptServer/demo.cpp                 |    5 
 QiaoJiaSystem/StructureApp/VptRpcElement.cpp     |  137 +++
 QiaoJiaSystem/StructureApp/AppPipeController.cpp |   11 
 QiaoJiaSystem/VptServer/VptDetectWrapper.cpp     |   10 
 QiaoJiaSystem/VptServer/rpc/gen.sh               |    2 
 QiaoJiaSystem/VideoAnalysFromHC/CMakeLists.txt   |    3 
 QiaoJiaSystem/VptServer/VptServerI.cpp           |    1 
 QiaoJiaSystem/VptServer/rpc/VptServer.ice        |    1 
 QiaoJiaSystem/StructureApp/CMakeLists.txt        |    1 
 QiaoJiaSystem/StructureApp/VptRpcElement.h       |   67 +
 QiaoJiaSystem/StructureApp/YoloRpcElement.cpp    |   97 +-
 QiaoJiaSystem/VptServer/VptDetectWrapper.h       |    2 
 QiaoJiaSystem/VptServer/main.cpp                 |    2 
 QiaoJiaSystem/VptServer/rpc/VptServer.h          | 2267 +++++++++++++++++++++++++-------------------------
 14 files changed, 1,401 insertions(+), 1,205 deletions(-)

diff --git a/QiaoJiaSystem/StructureApp/AppPipeController.cpp b/QiaoJiaSystem/StructureApp/AppPipeController.cpp
index 45c7773..4738830 100644
--- a/QiaoJiaSystem/StructureApp/AppPipeController.cpp
+++ b/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([&] {
 
diff --git a/QiaoJiaSystem/StructureApp/CMakeLists.txt b/QiaoJiaSystem/StructureApp/CMakeLists.txt
index b15b23e..8eaf3c2 100644
--- a/QiaoJiaSystem/StructureApp/CMakeLists.txt
+++ b/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
diff --git a/QiaoJiaSystem/StructureApp/VptRpcElement.cpp b/QiaoJiaSystem/StructureApp/VptRpcElement.cpp
new file mode 100644
index 0000000..8607438
--- /dev/null
+++ b/QiaoJiaSystem/StructureApp/VptRpcElement.cpp
@@ -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;
+}
+
diff --git a/QiaoJiaSystem/StructureApp/VptRpcElement.h b/QiaoJiaSystem/StructureApp/VptRpcElement.h
new file mode 100644
index 0000000..658f65c
--- /dev/null
+++ b/QiaoJiaSystem/StructureApp/VptRpcElement.h
@@ -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
diff --git a/QiaoJiaSystem/StructureApp/YoloRpcElement.cpp b/QiaoJiaSystem/StructureApp/YoloRpcElement.cpp
index e3ccd11..a5a914f 100644
--- a/QiaoJiaSystem/StructureApp/YoloRpcElement.cpp
+++ b/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();
 }
 
 
diff --git a/QiaoJiaSystem/VideoAnalysFromHC/CMakeLists.txt b/QiaoJiaSystem/VideoAnalysFromHC/CMakeLists.txt
index 838998b..65da203 100644
--- a/QiaoJiaSystem/VideoAnalysFromHC/CMakeLists.txt
+++ b/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
diff --git a/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp b/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp
index 186e7f5..8b6b353 100644
--- a/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp
+++ b/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) {
diff --git a/QiaoJiaSystem/VptServer/VptDetectWrapper.h b/QiaoJiaSystem/VptServer/VptDetectWrapper.h
index b0b65a8..0667476 100644
--- a/QiaoJiaSystem/VptServer/VptDetectWrapper.h
+++ b/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;
diff --git a/QiaoJiaSystem/VptServer/VptServerI.cpp b/QiaoJiaSystem/VptServer/VptServerI.cpp
index e08fa75..62f80ab 100644
--- a/QiaoJiaSystem/VptServer/VptServerI.cpp
+++ b/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_;
diff --git a/QiaoJiaSystem/VptServer/demo.cpp b/QiaoJiaSystem/VptServer/demo.cpp
index c97d4ed..47f6be4 100644
--- a/QiaoJiaSystem/VptServer/demo.cpp
+++ b/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];
diff --git a/QiaoJiaSystem/VptServer/main.cpp b/QiaoJiaSystem/VptServer/main.cpp
index f60dc52..fc7ca74 100644
--- a/QiaoJiaSystem/VptServer/main.cpp
+++ b/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);
diff --git a/QiaoJiaSystem/VptServer/rpc/VptServer.h b/QiaoJiaSystem/VptServer/rpc/VptServer.h
index dda6031..aaaa9eb 100644
--- a/QiaoJiaSystem/VptServer/rpc/VptServer.h
+++ b/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
diff --git a/QiaoJiaSystem/VptServer/rpc/VptServer.ice b/QiaoJiaSystem/VptServer/rpc/VptServer.ice
index 2969b88..a48aa7c 100644
--- a/QiaoJiaSystem/VptServer/rpc/VptServer.ice
+++ b/QiaoJiaSystem/VptServer/rpc/VptServer.ice
@@ -45,6 +45,7 @@
 
     struct VptDetectResult {
         int sdkDetectType;
+	    float obj_score;                            //妫�娴嬬疆淇″害
         RECT bskRect;
         PersonDetectRes personDetectRes;
         PerRideCarDetectRes perRideCarDetectRes;
diff --git a/QiaoJiaSystem/VptServer/rpc/gen.sh b/QiaoJiaSystem/VptServer/rpc/gen.sh
index c53310b..6c684db 100644
--- a/QiaoJiaSystem/VptServer/rpc/gen.sh
+++ b/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

--
Gitblit v1.8.0