init

CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(LidarMeasure)
+
+## Compile as C++11, supported in ROS Kinetic and newer
+add_compile_options(-std=c++11)
+
+#add_definitions(-std=c++11 -msse -msse2 -msse3 -msse4 -msse4.1 -msse4.2)
+
+FIND_PACKAGE(OpenCV REQUIRED)
+FIND_PACKAGE(PCL REQUIRED)
+FIND_PACKAGE(Protobuf REQUIRED)
+FIND_PACKAGE(Glog REQUIRED)
+set(CMAKE_MODULE_PATH "/usr/local/share/")
+
+set(CMAKE_CXX_FLAGS "-std=c++11 -msse -msse2 -msse3 -msse4 -msse4.1 -msse4.2")
+set(CMAKE_BUILD_TYPE "RELEASE")
+
+
+#find_package(Eigen3 REQUIRED)
+
+include_directories(
+        laser
+        plc
+        src
+        Locate
+        /usr/local/include/modbus
+  ${PCL_INCLUDE_DIRS}
+  ${OpenCV_INCLUDE_DIRS}
+)
+link_directories("/usr/local/lib")
+
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/laser LASER_SRC )
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/plc PLC_SRC )
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/Locate LOCATE_SRC )
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/terminor TERMINOR_SRC )
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/task TASK_MANAGER_SRC )
+
+
+add_executable(LidarMeasure ./main.cpp ${LASER_SRC} ${PLC_SRC} ${TERMINOR_SRC} ${LOCATE_SRC} ${TASK_MANAGER_SRC})
+target_link_libraries(LidarMeasure ${OpenCV_LIBS}
+        ${GLOG_LIBRARIES} ${PCL_LIBRARIES} ${PROTOBUF_LIBRARIES} ipopt libtensorflow_cc.so
+        tf_3dcnn_api.so pointSIFT_API.so dark.so /usr/local/lib/libglog.a /usr/local/lib/libmodbus.so
+        /usr/local/lib/libgflags.a /usr/local/lib/liblivox_sdk_static.a /usr/local/apr/lib/libapr-1.a nnxx nanomsg)
+
+

error.h

@@ -0,0 +1,19 @@
+
+enum ERROR_CODE
+{
+SUCCESS=0x00000000,
+
+
+LASER_INIT_FAILED	=				0x010102FF,
+
+
+
+PLC_INIT_ERROR=0x02010000,
+
+
+LOCATER_ERROR=0x03010000
+
+
+
+
+}

main.cpp

@@ -0,0 +1,18 @@
+//
+// Created by zx on 2019/12/28.
+//
+#include <iostream>
+#include "laser/Laser.h"
+#include "plc/ModbusPlc.h"
+#include "terminor/TerminorComandExecutor.h"
+
+int main(int argc,char* argv[])
+{
+    LidarMeasure::GlobalParameter parameter;
+    //读取配置文件
+    //根据配置创建雷达,plc,终端指令执行器
+
+    std::cout<<ERROR(0x0102030F);
+    getchar();
+    return 0;
+}

task/task_command_manager.cpp

@@ -0,0 +1,44 @@
+//
+// Created by zx on 2019/12/28.
+//
+
+#include "task_command_manager.h"
+#include "../error.h"
+
+Task_Base::Task_Base()
+{
+}
+Task_Base::~Task_Base()
+{
+
+}
+//初始化任务单,初始任务单类型为 UNKONW_TASK
+int Task_Base::init()
+{
+    m_task_type=UNKNOW_TASK;
+    return SUCCESS;
+}
+//更新任务单
+//task_statu: 任务状态
+//statu_information:状态说明
+int Task_Base::update_statu(Task_statu task_statu,std::string statu_information)
+{
+    m_task_statu=task_statu;
+    m_task_statu_information=statu_information;
+    return SUCCESS;
+}
+//获取任务类型
+Task_type Task_Base::get_task_type()
+{
+    return m_task_type;
+}
+//获取任务单状态
+Task_statu  Task_Base::get_statu()
+{
+    return m_task_statu;
+}
+//获取状态说明
+std::string Task_Base::get_statu_information()
+{
+    return m_task_statu_information;
+}

task/task_command_manager.h

@@ -0,0 +1,51 @@
+//
+// Created by zx on 2019/12/28.
+//
+
+#ifndef TASK_COMAND_MANAGER_H
+#define TASK_COMAND_MANAGER_H
+#include <string>
+
+//任务类型
+enum Task_type
+{
+    LASER_TASK=0,           //雷达扫描任务
+    LOCATE_TASK,            //测量任务
+    PLC_TASK,                //上传PLC任务
+    UNKNOW_TASK             //未知任务单/初始化
+};
+//任务状态
+enum Task_statu
+{
+    TASK_CREATED=0,     //创建状态
+    TASK_SIGNED,        //已签收
+    TASK_WORKING,       //处理中
+    TASK_OVER           //已结束
+};
+
+//
+class Task_Base
+{
+public:
+    Task_Base();
+    ~Task_Base();
+    //初始化任务单,初始任务单类型为 UNKONW_TASK
+    virtual int init();
+    //更新任务单
+    //task_statu: 任务状态
+    //statu_information:状态说明
+    int update_statu(Task_statu task_statu,std::string statu_information="");
+    //获取任务类型
+    Task_type   get_task_type();
+    //获取任务单状态
+    Task_statu  get_statu();
+    //获取状态说明
+    std::string get_statu_information();
+
+protected:
+    Task_type                   m_task_type;
+    Task_statu                  m_task_statu;               //任务状态
+    std::string                 m_task_statu_information;        //任务状态说明
+};
+
+#endif //TASK_COMAND_MANAGER_H

terminor/TerminorComandExecutor.h

@@ -0,0 +1,57 @@
+//
+// Created by zx on 2019/12/27.
+//
+
+#ifndef TERMINOR_H
+#define TERMINOR_H
+
+#include "Laser.h"
+#include "ModbusPlc.h"
+#include "Terminor_parameter.pb.h"
+/*
+ * 终端指令执行状态,枚举
+ * 列举终端指令从进入流程到测量完成过程中的进度状态
+ */
+enum TerminorStatu
+{
+    TERMINOR_READY=0,           //终端空闲
+    TERMINOR_WAIT_LASER,        //终端收到指令,等待雷达资源
+    TERMINOR_SCANNING,          //终端指令一启动扫描,扫描中
+    TERMINOR_WAIT_MEASURE,      //终端指令扫描完成,指令进入等待测量中
+    TERMINOR_MEASURING,         //终端指令进入测量中
+    TERMINOR_UNKNOW             //未知状态
+};
+
+/*
+ * 终端指令执行类,执行指令,监控指令执行进度
+ * 输入雷达数组,plc对象,测量算法对象,执行扫描测量任务
+ */
+class TerminorCommandExecutor
+{
+public:
+    /*
+     * 构造函数
+     * parameter:该终端指令配置参数(待定)
+     */
+    TerminorCommandExecutor(LidarMeasure::Terminor_parameter parameter);
+    /*
+     * 获取终端进度状态
+     */
+    int get_statu(TerminorStatu& statu);
+    /*
+     * 执行扫描,测量任务,阻塞知道任务完成或超时(单位秒)
+     *lasers:需要启动的雷达
+     * plc:上传结果工具
+     * locater:测量算法对象
+     */
+    int execute_command(std::vector<Laser*> lasers,ModbusPlc* plc,
+        Locater* locater,int timeout=15);
+    /*
+     * 强制正在执行的中断指令
+     */
+    int force_stop_command();
+protected:
+
+};
+
+#endif //TERMINOR_H

terminor/Terminor_parameter.pb.cc

@@ -0,0 +1,878 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Terminor_parameter.proto
+
+#include "Terminor_parameter.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// This is a temporary google only hack
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+#include "third_party/protobuf/version.h"
+#endif
+// @@protoc_insertion_point(includes)
+namespace LidarMeasure {
+class Area3dDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<Area3d>
+      _instance;
+} _Area3d_default_instance_;
+class Terminor_parameterDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<Terminor_parameter>
+      _instance;
+} _Terminor_parameter_default_instance_;
+}  // namespace LidarMeasure
+namespace protobuf_Terminor_5fparameter_2eproto {
+void InitDefaultsArea3dImpl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
+#else
+  ::google::protobuf::internal::InitProtobufDefaults();
+#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  {
+    void* ptr = &::LidarMeasure::_Area3d_default_instance_;
+    new (ptr) ::LidarMeasure::Area3d();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::LidarMeasure::Area3d::InitAsDefaultInstance();
+}
+
+void InitDefaultsArea3d() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsArea3dImpl);
+}
+
+void InitDefaultsTerminor_parameterImpl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
+#else
+  ::google::protobuf::internal::InitProtobufDefaults();
+#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  protobuf_Terminor_5fparameter_2eproto::InitDefaultsArea3d();
+  {
+    void* ptr = &::LidarMeasure::_Terminor_parameter_default_instance_;
+    new (ptr) ::LidarMeasure::Terminor_parameter();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::LidarMeasure::Terminor_parameter::InitAsDefaultInstance();
+}
+
+void InitDefaultsTerminor_parameter() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTerminor_parameterImpl);
+}
+
+::google::protobuf::Metadata file_level_metadata[2];
+
+const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, _has_bits_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, min_x_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, max_x_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, min_y_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, max_y_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, min_z_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Area3d, max_z_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Terminor_parameter, _has_bits_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Terminor_parameter, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::LidarMeasure::Terminor_parameter, area_3d_),
+  0,
+};
+static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 11, sizeof(::LidarMeasure::Area3d)},
+  { 17, 23, sizeof(::LidarMeasure::Terminor_parameter)},
+};
+
+static ::google::protobuf::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::google::protobuf::Message*>(&::LidarMeasure::_Area3d_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::LidarMeasure::_Terminor_parameter_default_instance_),
+};
+
+void protobuf_AssignDescriptors() {
+  AddDescriptors();
+  ::google::protobuf::MessageFactory* factory = NULL;
+  AssignDescriptors(
+      "Terminor_parameter.proto", schemas, file_default_instances, TableStruct::offsets, factory,
+      file_level_metadata, NULL, NULL);
+}
+
+void protobuf_AssignDescriptorsOnce() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 2);
+}
+
+void AddDescriptorsImpl() {
+  InitDefaults();
+  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+      "\n\030Terminor_parameter.proto\022\014LidarMeasure"
+      "\"b\n\006Area3d\022\r\n\005min_x\030\001 \002(\002\022\r\n\005max_x\030\002 \002(\002"
+      "\022\r\n\005min_y\030\003 \002(\002\022\r\n\005max_y\030\004 \002(\002\022\r\n\005min_z\030"
+      "\005 \002(\002\022\r\n\005max_z\030\006 \002(\002\";\n\022Terminor_paramet"
+      "er\022%\n\007area_3d\030\001 \002(\0132\024.LidarMeasure.Area3"
+      "d"
+  };
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+      descriptor, 201);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "Terminor_parameter.proto", &protobuf_RegisterTypes);
+}
+
+void AddDescriptors() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
+}
+// Force AddDescriptors() to be called at dynamic initialization time.
+struct StaticDescriptorInitializer {
+  StaticDescriptorInitializer() {
+    AddDescriptors();
+  }
+} static_descriptor_initializer;
+}  // namespace protobuf_Terminor_5fparameter_2eproto
+namespace LidarMeasure {
+
+// ===================================================================
+
+void Area3d::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int Area3d::kMinXFieldNumber;
+const int Area3d::kMaxXFieldNumber;
+const int Area3d::kMinYFieldNumber;
+const int Area3d::kMaxYFieldNumber;
+const int Area3d::kMinZFieldNumber;
+const int Area3d::kMaxZFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+Area3d::Area3d()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
+    ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsArea3d();
+  }
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:LidarMeasure.Area3d)
+}
+Area3d::Area3d(const Area3d& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      _has_bits_(from._has_bits_),
+      _cached_size_(0) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::memcpy(&min_x_, &from.min_x_,
+    static_cast<size_t>(reinterpret_cast<char*>(&max_z_) -
+    reinterpret_cast<char*>(&min_x_)) + sizeof(max_z_));
+  // @@protoc_insertion_point(copy_constructor:LidarMeasure.Area3d)
+}
+
+void Area3d::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(&min_x_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&max_z_) -
+      reinterpret_cast<char*>(&min_x_)) + sizeof(max_z_));
+}
+
+Area3d::~Area3d() {
+  // @@protoc_insertion_point(destructor:LidarMeasure.Area3d)
+  SharedDtor();
+}
+
+void Area3d::SharedDtor() {
+}
+
+void Area3d::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Area3d::descriptor() {
+  ::protobuf_Terminor_5fparameter_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_Terminor_5fparameter_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const Area3d& Area3d::default_instance() {
+  ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsArea3d();
+  return *internal_default_instance();
+}
+
+Area3d* Area3d::New(::google::protobuf::Arena* arena) const {
+  Area3d* n = new Area3d;
+  if (arena != NULL) {
+    arena->Own(n);
+  }
+  return n;
+}
+
+void Area3d::Clear() {
+// @@protoc_insertion_point(message_clear_start:LidarMeasure.Area3d)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 63u) {
+    ::memset(&min_x_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&max_z_) -
+        reinterpret_cast<char*>(&min_x_)) + sizeof(max_z_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool Area3d::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:LidarMeasure.Area3d)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required float min_x = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
+          set_has_min_x();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &min_x_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required float max_x = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
+          set_has_max_x();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &max_x_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required float min_y = 3;
+      case 3: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
+          set_has_min_y();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &min_y_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required float max_y = 4;
+      case 4: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
+          set_has_max_y();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &max_y_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required float min_z = 5;
+      case 5: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
+          set_has_min_z();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &min_z_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required float max_z = 6;
+      case 6: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) {
+          set_has_max_z();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &max_z_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:LidarMeasure.Area3d)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:LidarMeasure.Area3d)
+  return false;
+#undef DO_
+}
+
+void Area3d::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:LidarMeasure.Area3d)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required float min_x = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->min_x(), output);
+  }
+
+  // required float max_x = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->max_x(), output);
+  }
+
+  // required float min_y = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->min_y(), output);
+  }
+
+  // required float max_y = 4;
+  if (cached_has_bits & 0x00000008u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->max_y(), output);
+  }
+
+  // required float min_z = 5;
+  if (cached_has_bits & 0x00000010u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->min_z(), output);
+  }
+
+  // required float max_z = 6;
+  if (cached_has_bits & 0x00000020u) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->max_z(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:LidarMeasure.Area3d)
+}
+
+::google::protobuf::uint8* Area3d::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:LidarMeasure.Area3d)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required float min_x = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->min_x(), target);
+  }
+
+  // required float max_x = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->max_x(), target);
+  }
+
+  // required float min_y = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->min_y(), target);
+  }
+
+  // required float max_y = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->max_y(), target);
+  }
+
+  // required float min_z = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->min_z(), target);
+  }
+
+  // required float max_z = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->max_z(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:LidarMeasure.Area3d)
+  return target;
+}
+
+size_t Area3d::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:LidarMeasure.Area3d)
+  size_t total_size = 0;
+
+  if (has_min_x()) {
+    // required float min_x = 1;
+    total_size += 1 + 4;
+  }
+
+  if (has_max_x()) {
+    // required float max_x = 2;
+    total_size += 1 + 4;
+  }
+
+  if (has_min_y()) {
+    // required float min_y = 3;
+    total_size += 1 + 4;
+  }
+
+  if (has_max_y()) {
+    // required float max_y = 4;
+    total_size += 1 + 4;
+  }
+
+  if (has_min_z()) {
+    // required float min_z = 5;
+    total_size += 1 + 4;
+  }
+
+  if (has_max_z()) {
+    // required float max_z = 6;
+    total_size += 1 + 4;
+  }
+
+  return total_size;
+}
+size_t Area3d::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:LidarMeasure.Area3d)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
+    // required float min_x = 1;
+    total_size += 1 + 4;
+
+    // required float max_x = 2;
+    total_size += 1 + 4;
+
+    // required float min_y = 3;
+    total_size += 1 + 4;
+
+    // required float max_y = 4;
+    total_size += 1 + 4;
+
+    // required float min_z = 5;
+    total_size += 1 + 4;
+
+    // required float max_z = 6;
+    total_size += 1 + 4;
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = cached_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Area3d::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:LidarMeasure.Area3d)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Area3d* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const Area3d>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:LidarMeasure.Area3d)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:LidarMeasure.Area3d)
+    MergeFrom(*source);
+  }
+}
+
+void Area3d::MergeFrom(const Area3d& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:LidarMeasure.Area3d)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 63u) {
+    if (cached_has_bits & 0x00000001u) {
+      min_x_ = from.min_x_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      max_x_ = from.max_x_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      min_y_ = from.min_y_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      max_y_ = from.max_y_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      min_z_ = from.min_z_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      max_z_ = from.max_z_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void Area3d::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:LidarMeasure.Area3d)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Area3d::CopyFrom(const Area3d& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:LidarMeasure.Area3d)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Area3d::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
+  return true;
+}
+
+void Area3d::Swap(Area3d* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void Area3d::InternalSwap(Area3d* other) {
+  using std::swap;
+  swap(min_x_, other->min_x_);
+  swap(max_x_, other->max_x_);
+  swap(min_y_, other->min_y_);
+  swap(max_y_, other->max_y_);
+  swap(min_z_, other->min_z_);
+  swap(max_z_, other->max_z_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(_cached_size_, other->_cached_size_);
+}
+
+::google::protobuf::Metadata Area3d::GetMetadata() const {
+  protobuf_Terminor_5fparameter_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_Terminor_5fparameter_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void Terminor_parameter::InitAsDefaultInstance() {
+  ::LidarMeasure::_Terminor_parameter_default_instance_._instance.get_mutable()->area_3d_ = const_cast< ::LidarMeasure::Area3d*>(
+      ::LidarMeasure::Area3d::internal_default_instance());
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int Terminor_parameter::kArea3DFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+Terminor_parameter::Terminor_parameter()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
+    ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsTerminor_parameter();
+  }
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:LidarMeasure.Terminor_parameter)
+}
+Terminor_parameter::Terminor_parameter(const Terminor_parameter& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      _has_bits_(from._has_bits_),
+      _cached_size_(0) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_area_3d()) {
+    area_3d_ = new ::LidarMeasure::Area3d(*from.area_3d_);
+  } else {
+    area_3d_ = NULL;
+  }
+  // @@protoc_insertion_point(copy_constructor:LidarMeasure.Terminor_parameter)
+}
+
+void Terminor_parameter::SharedCtor() {
+  _cached_size_ = 0;
+  area_3d_ = NULL;
+}
+
+Terminor_parameter::~Terminor_parameter() {
+  // @@protoc_insertion_point(destructor:LidarMeasure.Terminor_parameter)
+  SharedDtor();
+}
+
+void Terminor_parameter::SharedDtor() {
+  if (this != internal_default_instance()) delete area_3d_;
+}
+
+void Terminor_parameter::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Terminor_parameter::descriptor() {
+  ::protobuf_Terminor_5fparameter_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_Terminor_5fparameter_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const Terminor_parameter& Terminor_parameter::default_instance() {
+  ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsTerminor_parameter();
+  return *internal_default_instance();
+}
+
+Terminor_parameter* Terminor_parameter::New(::google::protobuf::Arena* arena) const {
+  Terminor_parameter* n = new Terminor_parameter;
+  if (arena != NULL) {
+    arena->Own(n);
+  }
+  return n;
+}
+
+void Terminor_parameter::Clear() {
+// @@protoc_insertion_point(message_clear_start:LidarMeasure.Terminor_parameter)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(area_3d_ != NULL);
+    area_3d_->Clear();
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool Terminor_parameter::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:LidarMeasure.Terminor_parameter)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .LidarMeasure.Area3d area_3d = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
+               input, mutable_area_3d()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:LidarMeasure.Terminor_parameter)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:LidarMeasure.Terminor_parameter)
+  return false;
+#undef DO_
+}
+
+void Terminor_parameter::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:LidarMeasure.Terminor_parameter)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required .LidarMeasure.Area3d area_3d = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, *this->area_3d_, output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:LidarMeasure.Terminor_parameter)
+}
+
+::google::protobuf::uint8* Terminor_parameter::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:LidarMeasure.Terminor_parameter)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required .LidarMeasure.Area3d area_3d = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, *this->area_3d_, deterministic, target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:LidarMeasure.Terminor_parameter)
+  return target;
+}
+
+size_t Terminor_parameter::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:LidarMeasure.Terminor_parameter)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  // required .LidarMeasure.Area3d area_3d = 1;
+  if (has_area_3d()) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *this->area_3d_);
+  }
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = cached_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Terminor_parameter::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:LidarMeasure.Terminor_parameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Terminor_parameter* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const Terminor_parameter>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:LidarMeasure.Terminor_parameter)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:LidarMeasure.Terminor_parameter)
+    MergeFrom(*source);
+  }
+}
+
+void Terminor_parameter::MergeFrom(const Terminor_parameter& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:LidarMeasure.Terminor_parameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.has_area_3d()) {
+    mutable_area_3d()->::LidarMeasure::Area3d::MergeFrom(from.area_3d());
+  }
+}
+
+void Terminor_parameter::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:LidarMeasure.Terminor_parameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Terminor_parameter::CopyFrom(const Terminor_parameter& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:LidarMeasure.Terminor_parameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Terminor_parameter::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  if (has_area_3d()) {
+    if (!this->area_3d_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Terminor_parameter::Swap(Terminor_parameter* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void Terminor_parameter::InternalSwap(Terminor_parameter* other) {
+  using std::swap;
+  swap(area_3d_, other->area_3d_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(_cached_size_, other->_cached_size_);
+}
+
+::google::protobuf::Metadata Terminor_parameter::GetMetadata() const {
+  protobuf_Terminor_5fparameter_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_Terminor_5fparameter_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace LidarMeasure
+
+// @@protoc_insertion_point(global_scope)

terminor/Terminor_parameter.pb.h

@@ -0,0 +1,564 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Terminor_parameter.proto
+
+#ifndef PROTOBUF_Terminor_5fparameter_2eproto__INCLUDED
+#define PROTOBUF_Terminor_5fparameter_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Terminor_5fparameter_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[2];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsArea3dImpl();
+void InitDefaultsArea3d();
+void InitDefaultsTerminor_parameterImpl();
+void InitDefaultsTerminor_parameter();
+inline void InitDefaults() {
+  InitDefaultsArea3d();
+  InitDefaultsTerminor_parameter();
+}
+}  // namespace protobuf_Terminor_5fparameter_2eproto
+namespace LidarMeasure {
+class Area3d;
+class Area3dDefaultTypeInternal;
+extern Area3dDefaultTypeInternal _Area3d_default_instance_;
+class Terminor_parameter;
+class Terminor_parameterDefaultTypeInternal;
+extern Terminor_parameterDefaultTypeInternal _Terminor_parameter_default_instance_;
+}  // namespace LidarMeasure
+namespace LidarMeasure {
+
+// ===================================================================
+
+class Area3d : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:LidarMeasure.Area3d) */ {
+ public:
+  Area3d();
+  virtual ~Area3d();
+
+  Area3d(const Area3d& from);
+
+  inline Area3d& operator=(const Area3d& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Area3d(Area3d&& from) noexcept
+    : Area3d() {
+    *this = ::std::move(from);
+  }
+
+  inline Area3d& operator=(Area3d&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Area3d& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Area3d* internal_default_instance() {
+    return reinterpret_cast<const Area3d*>(
+               &_Area3d_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Area3d* other);
+  friend void swap(Area3d& a, Area3d& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Area3d* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Area3d* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Area3d& from);
+  void MergeFrom(const Area3d& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Area3d* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required float min_x = 1;
+  bool has_min_x() const;
+  void clear_min_x();
+  static const int kMinXFieldNumber = 1;
+  float min_x() const;
+  void set_min_x(float value);
+
+  // required float max_x = 2;
+  bool has_max_x() const;
+  void clear_max_x();
+  static const int kMaxXFieldNumber = 2;
+  float max_x() const;
+  void set_max_x(float value);
+
+  // required float min_y = 3;
+  bool has_min_y() const;
+  void clear_min_y();
+  static const int kMinYFieldNumber = 3;
+  float min_y() const;
+  void set_min_y(float value);
+
+  // required float max_y = 4;
+  bool has_max_y() const;
+  void clear_max_y();
+  static const int kMaxYFieldNumber = 4;
+  float max_y() const;
+  void set_max_y(float value);
+
+  // required float min_z = 5;
+  bool has_min_z() const;
+  void clear_min_z();
+  static const int kMinZFieldNumber = 5;
+  float min_z() const;
+  void set_min_z(float value);
+
+  // required float max_z = 6;
+  bool has_max_z() const;
+  void clear_max_z();
+  static const int kMaxZFieldNumber = 6;
+  float max_z() const;
+  void set_max_z(float value);
+
+  // @@protoc_insertion_point(class_scope:LidarMeasure.Area3d)
+ private:
+  void set_has_min_x();
+  void clear_has_min_x();
+  void set_has_max_x();
+  void clear_has_max_x();
+  void set_has_min_y();
+  void clear_has_min_y();
+  void set_has_max_y();
+  void clear_has_max_y();
+  void set_has_min_z();
+  void clear_has_min_z();
+  void set_has_max_z();
+  void clear_has_max_z();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  float min_x_;
+  float max_x_;
+  float min_y_;
+  float max_y_;
+  float min_z_;
+  float max_z_;
+  friend struct ::protobuf_Terminor_5fparameter_2eproto::TableStruct;
+  friend void ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsArea3dImpl();
+};
+// -------------------------------------------------------------------
+
+class Terminor_parameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:LidarMeasure.Terminor_parameter) */ {
+ public:
+  Terminor_parameter();
+  virtual ~Terminor_parameter();
+
+  Terminor_parameter(const Terminor_parameter& from);
+
+  inline Terminor_parameter& operator=(const Terminor_parameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Terminor_parameter(Terminor_parameter&& from) noexcept
+    : Terminor_parameter() {
+    *this = ::std::move(from);
+  }
+
+  inline Terminor_parameter& operator=(Terminor_parameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Terminor_parameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Terminor_parameter* internal_default_instance() {
+    return reinterpret_cast<const Terminor_parameter*>(
+               &_Terminor_parameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Terminor_parameter* other);
+  friend void swap(Terminor_parameter& a, Terminor_parameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Terminor_parameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Terminor_parameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Terminor_parameter& from);
+  void MergeFrom(const Terminor_parameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Terminor_parameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .LidarMeasure.Area3d area_3d = 1;
+  bool has_area_3d() const;
+  void clear_area_3d();
+  static const int kArea3DFieldNumber = 1;
+  const ::LidarMeasure::Area3d& area_3d() const;
+  ::LidarMeasure::Area3d* release_area_3d();
+  ::LidarMeasure::Area3d* mutable_area_3d();
+  void set_allocated_area_3d(::LidarMeasure::Area3d* area_3d);
+
+  // @@protoc_insertion_point(class_scope:LidarMeasure.Terminor_parameter)
+ private:
+  void set_has_area_3d();
+  void clear_has_area_3d();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::LidarMeasure::Area3d* area_3d_;
+  friend struct ::protobuf_Terminor_5fparameter_2eproto::TableStruct;
+  friend void ::protobuf_Terminor_5fparameter_2eproto::InitDefaultsTerminor_parameterImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Area3d
+
+// required float min_x = 1;
+inline bool Area3d::has_min_x() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Area3d::set_has_min_x() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Area3d::clear_has_min_x() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Area3d::clear_min_x() {
+  min_x_ = 0;
+  clear_has_min_x();
+}
+inline float Area3d::min_x() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.min_x)
+  return min_x_;
+}
+inline void Area3d::set_min_x(float value) {
+  set_has_min_x();
+  min_x_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.min_x)
+}
+
+// required float max_x = 2;
+inline bool Area3d::has_max_x() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Area3d::set_has_max_x() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Area3d::clear_has_max_x() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Area3d::clear_max_x() {
+  max_x_ = 0;
+  clear_has_max_x();
+}
+inline float Area3d::max_x() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.max_x)
+  return max_x_;
+}
+inline void Area3d::set_max_x(float value) {
+  set_has_max_x();
+  max_x_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.max_x)
+}
+
+// required float min_y = 3;
+inline bool Area3d::has_min_y() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Area3d::set_has_min_y() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Area3d::clear_has_min_y() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Area3d::clear_min_y() {
+  min_y_ = 0;
+  clear_has_min_y();
+}
+inline float Area3d::min_y() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.min_y)
+  return min_y_;
+}
+inline void Area3d::set_min_y(float value) {
+  set_has_min_y();
+  min_y_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.min_y)
+}
+
+// required float max_y = 4;
+inline bool Area3d::has_max_y() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Area3d::set_has_max_y() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Area3d::clear_has_max_y() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Area3d::clear_max_y() {
+  max_y_ = 0;
+  clear_has_max_y();
+}
+inline float Area3d::max_y() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.max_y)
+  return max_y_;
+}
+inline void Area3d::set_max_y(float value) {
+  set_has_max_y();
+  max_y_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.max_y)
+}
+
+// required float min_z = 5;
+inline bool Area3d::has_min_z() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Area3d::set_has_min_z() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Area3d::clear_has_min_z() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Area3d::clear_min_z() {
+  min_z_ = 0;
+  clear_has_min_z();
+}
+inline float Area3d::min_z() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.min_z)
+  return min_z_;
+}
+inline void Area3d::set_min_z(float value) {
+  set_has_min_z();
+  min_z_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.min_z)
+}
+
+// required float max_z = 6;
+inline bool Area3d::has_max_z() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Area3d::set_has_max_z() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Area3d::clear_has_max_z() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Area3d::clear_max_z() {
+  max_z_ = 0;
+  clear_has_max_z();
+}
+inline float Area3d::max_z() const {
+  // @@protoc_insertion_point(field_get:LidarMeasure.Area3d.max_z)
+  return max_z_;
+}
+inline void Area3d::set_max_z(float value) {
+  set_has_max_z();
+  max_z_ = value;
+  // @@protoc_insertion_point(field_set:LidarMeasure.Area3d.max_z)
+}
+
+// -------------------------------------------------------------------
+
+// Terminor_parameter
+
+// required .LidarMeasure.Area3d area_3d = 1;
+inline bool Terminor_parameter::has_area_3d() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Terminor_parameter::set_has_area_3d() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Terminor_parameter::clear_has_area_3d() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Terminor_parameter::clear_area_3d() {
+  if (area_3d_ != NULL) area_3d_->Clear();
+  clear_has_area_3d();
+}
+inline const ::LidarMeasure::Area3d& Terminor_parameter::area_3d() const {
+  const ::LidarMeasure::Area3d* p = area_3d_;
+  // @@protoc_insertion_point(field_get:LidarMeasure.Terminor_parameter.area_3d)
+  return p != NULL ? *p : *reinterpret_cast<const ::LidarMeasure::Area3d*>(
+      &::LidarMeasure::_Area3d_default_instance_);
+}
+inline ::LidarMeasure::Area3d* Terminor_parameter::release_area_3d() {
+  // @@protoc_insertion_point(field_release:LidarMeasure.Terminor_parameter.area_3d)
+  clear_has_area_3d();
+  ::LidarMeasure::Area3d* temp = area_3d_;
+  area_3d_ = NULL;
+  return temp;
+}
+inline ::LidarMeasure::Area3d* Terminor_parameter::mutable_area_3d() {
+  set_has_area_3d();
+  if (area_3d_ == NULL) {
+    area_3d_ = new ::LidarMeasure::Area3d;
+  }
+  // @@protoc_insertion_point(field_mutable:LidarMeasure.Terminor_parameter.area_3d)
+  return area_3d_;
+}
+inline void Terminor_parameter::set_allocated_area_3d(::LidarMeasure::Area3d* area_3d) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete area_3d_;
+  }
+  if (area_3d) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      area_3d = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, area_3d, submessage_arena);
+    }
+    set_has_area_3d();
+  } else {
+    clear_has_area_3d();
+  }
+  area_3d_ = area_3d;
+  // @@protoc_insertion_point(field_set_allocated:LidarMeasure.Terminor_parameter.area_3d)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace LidarMeasure
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Terminor_5fparameter_2eproto__INCLUDED

terminor/Terminor_parameter.proto

@@ -0,0 +1,16 @@
+syntax="proto2";
+package LidarMeasure;
+
+message Area3d
+{
+    required float min_x=1;
+    required float max_x=2;
+    required float min_y=3;
+    required float max_y=4;
+    required float min_z=5;
+    required float max_z=6;
+}
+message Terminor_parameter
+{
+    required Area3d area_3d=1;
+}