Rearrage include and src

src/mynteye/api/processor/depth_processor.cc

@@ -0,0 +1,53 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "mynteye/api/processor/depth_processor.h"
+
+#include <utility>
+
+#include "mynteye/logger.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+const char DepthProcessor::NAME[] = "DepthProcessor";
+
+DepthProcessor::DepthProcessor(std::int32_t proc_period)
+    : Processor(std::move(proc_period)) {
+  VLOG(2) << __func__ << ": proc_period=" << proc_period;
+}
+
+DepthProcessor::~DepthProcessor() {
+  VLOG(2) << __func__;
+}
+
+std::string DepthProcessor::Name() {
+  return NAME;
+}
+
+Object *DepthProcessor::OnCreateOutput() {
+  return new ObjMat();
+}
+
+bool DepthProcessor::OnProcess(
+    Object *const in, Object *const out, Processor *const parent) {
+  MYNTEYE_UNUSED(parent)
+  const ObjMat *input = Object::Cast<ObjMat>(in);
+  ObjMat *output = Object::Cast<ObjMat>(out);
+  cv::Mat channels[3 /*input->value.channels()*/];
+  cv::split(input->value, channels);
+  channels[2].convertTo(output->value, CV_16UC1);
+  output->id = input->id;
+  return true;
+}
+
+MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/depth_processor.h

@@ -0,0 +1,41 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef MYNTEYE_API_PROCESSOR_DEPTH_PROCESSOR_H_
+#define MYNTEYE_API_PROCESSOR_DEPTH_PROCESSOR_H_
+#pragma once
+
+#include <string>
+
+#include "mynteye/api/processor.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+class DepthProcessor : public Processor {
+ public:
+  static const char NAME[];
+
+  explicit DepthProcessor(std::int32_t proc_period = 0);
+  virtual ~DepthProcessor();
+
+  std::string Name() override;
+
+ protected:
+  Object *OnCreateOutput() override;
+  bool OnProcess(
+      Object *const in, Object *const out, Processor *const parent) override;
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_API_PROCESSOR_DEPTH_PROCESSOR_H_

src/mynteye/api/processor/disparity_normalized_processor.cc

@@ -0,0 +1,56 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "mynteye/api/processor/disparity_normalized_processor.h"
+
+#include <utility>
+
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include "mynteye/logger.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+const char DisparityNormalizedProcessor::NAME[] =
+    "DisparityNormalizedProcessor";
+
+DisparityNormalizedProcessor::DisparityNormalizedProcessor(
+    std::int32_t proc_period)
+    : Processor(std::move(proc_period)) {
+  VLOG(2) << __func__ << ": proc_period=" << proc_period;
+}
+
+DisparityNormalizedProcessor::~DisparityNormalizedProcessor() {
+  VLOG(2) << __func__;
+}
+
+std::string DisparityNormalizedProcessor::Name() {
+  return NAME;
+}
+
+Object *DisparityNormalizedProcessor::OnCreateOutput() {
+  return new ObjMat();
+}
+
+bool DisparityNormalizedProcessor::OnProcess(
+    Object *const in, Object *const out, Processor *const parent) {
+  MYNTEYE_UNUSED(parent)
+  const ObjMat *input = Object::Cast<ObjMat>(in);
+  ObjMat *output = Object::Cast<ObjMat>(out);
+  cv::normalize(input->value, output->value, 0, 255, cv::NORM_MINMAX, CV_8UC1);
+  // cv::normalize maybe return empty ==
+  output->id = input->id;
+  return !output->value.empty();
+}
+
+MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/disparity_normalized_processor.h

@@ -0,0 +1,41 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef MYNTEYE_API_PROCESSOR_DISPARITY_NORMALIZED_PROCESSOR_H_
+#define MYNTEYE_API_PROCESSOR_DISPARITY_NORMALIZED_PROCESSOR_H_
+#pragma once
+
+#include <string>
+
+#include "mynteye/api/processor.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+class DisparityNormalizedProcessor : public Processor {
+ public:
+  static const char NAME[];
+
+  explicit DisparityNormalizedProcessor(std::int32_t proc_period = 0);
+  virtual ~DisparityNormalizedProcessor();
+
+  std::string Name() override;
+
+ protected:
+  Object *OnCreateOutput() override;
+  bool OnProcess(
+      Object *const in, Object *const out, Processor *const parent) override;
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_API_PROCESSOR_DISPARITY_NORMALIZED_PROCESSOR_H_

src/mynteye/api/processor/disparity_processor.cc

@@ -0,0 +1,106 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "mynteye/api/processor/disparity_processor.h"
+
+#include <utility>
+
+#include <opencv2/calib3d/calib3d.hpp>
+
+#include "mynteye/logger.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+const char DisparityProcessor::NAME[] = "DisparityProcessor";
+
+DisparityProcessor::DisparityProcessor(std::int32_t proc_period)
+    : Processor(std::move(proc_period)) {
+  VLOG(2) << __func__ << ": proc_period=" << proc_period;
+  int sgbmWinSize = 3;
+  int numberOfDisparities = 64;
+
+#ifdef USE_OPENCV2
+  // StereoSGBM
+  //   http://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html?#stereosgbm
+  sgbm_ = cv::Ptr<cv::StereoSGBM>(
+      new cv::StereoSGBM(
+          0,                               // minDisparity
+          numberOfDisparities,             // numDisparities
+          sgbmWinSize,                     // SADWindowSize
+          8 * sgbmWinSize * sgbmWinSize,   // P1
+          32 * sgbmWinSize * sgbmWinSize,  // P2
+          1,                               // disp12MaxDiff
+          63,                              // preFilterCap
+          10,                              // uniquenessRatio
+          100,                             // speckleWindowSize
+          32,                              // speckleRange
+          false));                         // fullDP
+#else
+  sgbm_ = cv::StereoSGBM::create(0, 16, 3);
+  sgbm_->setPreFilterCap(63);
+  sgbm_->setBlockSize(sgbmWinSize);
+  sgbm_->setP1(8 * sgbmWinSize * sgbmWinSize);
+  sgbm_->setP2(32 * sgbmWinSize * sgbmWinSize);
+  sgbm_->setMinDisparity(0);
+  sgbm_->setNumDisparities(numberOfDisparities);
+  sgbm_->setUniquenessRatio(10);
+  sgbm_->setSpeckleWindowSize(100);
+  sgbm_->setSpeckleRange(32);
+  sgbm_->setDisp12MaxDiff(1);
+#endif
+}
+
+DisparityProcessor::~DisparityProcessor() {
+  VLOG(2) << __func__;
+}
+
+std::string DisparityProcessor::Name() {
+  return NAME;
+}
+
+Object *DisparityProcessor::OnCreateOutput() {
+  return new ObjMat();
+}
+
+bool DisparityProcessor::OnProcess(
+    Object *const in, Object *const out, Processor *const parent) {
+  MYNTEYE_UNUSED(parent)
+  const ObjMat2 *input = Object::Cast<ObjMat2>(in);
+  ObjMat *output = Object::Cast<ObjMat>(out);
+
+  cv::Mat disparity;
+#ifdef USE_OPENCV2
+  // StereoSGBM::operator()
+  //   http://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#stereosgbm-operator
+  // Output disparity map. It is a 16-bit signed single-channel image of the
+  // same size as the input image.
+  // It contains disparity values scaled by 16. So, to get the floating-point
+  // disparity map,
+  // you need to divide each disp element by 16.
+  (*sgbm_)(input->first, input->second, disparity);
+#else
+  // compute()
+  //   http://docs.opencv.org/master/d2/d6e/classcv_1_1StereoMatcher.html
+  // Output disparity map. It has the same size as the input images.
+  // Some algorithms, like StereoBM or StereoSGBM compute 16-bit fixed-point
+  // disparity map
+  // (where each disparity value has 4 fractional bits),
+  // whereas other algorithms output 32-bit floating-point disparity map.
+  sgbm_->compute(input->first, input->second, disparity);
+#endif
+  output->value = disparity / 16 + 1;
+  output->id = input->first_id;
+  return true;
+}
+
+MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/disparity_processor.h

@@ -0,0 +1,50 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef MYNTEYE_API_PROCESSOR_DISPARITY_PROCESSOR_H_
+#define MYNTEYE_API_PROCESSOR_DISPARITY_PROCESSOR_H_
+#pragma once
+
+#include <string>
+
+#include "mynteye/api/processor.h"
+
+namespace cv {
+
+class StereoSGBM;
+
+}  // namespace cv
+
+MYNTEYE_BEGIN_NAMESPACE
+
+class DisparityProcessor : public Processor {
+ public:
+  static const char NAME[];
+
+  explicit DisparityProcessor(std::int32_t proc_period = 0);
+  virtual ~DisparityProcessor();
+
+  std::string Name() override;
+
+ protected:
+  Object *OnCreateOutput() override;
+  bool OnProcess(
+      Object *const in, Object *const out, Processor *const parent) override;
+
+ private:
+  cv::Ptr<cv::StereoSGBM> sgbm_;
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_API_PROCESSOR_DISPARITY_PROCESSOR_H_

src/mynteye/api/processor/points_processor.cc

@@ -0,0 +1,53 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "mynteye/api/processor/points_processor.h"
+
+#include <utility>
+
+#include <opencv2/calib3d/calib3d.hpp>
+
+#include "mynteye/logger.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+const char PointsProcessor::NAME[] = "PointsProcessor";
+
+PointsProcessor::PointsProcessor(cv::Mat Q, std::int32_t proc_period)
+    : Processor(std::move(proc_period)), Q_(std::move(Q)) {
+  VLOG(2) << __func__ << ": proc_period=" << proc_period;
+}
+
+PointsProcessor::~PointsProcessor() {
+  VLOG(2) << __func__;
+}
+
+std::string PointsProcessor::Name() {
+  return NAME;
+}
+
+Object *PointsProcessor::OnCreateOutput() {
+  return new ObjMat();
+}
+
+bool PointsProcessor::OnProcess(
+    Object *const in, Object *const out, Processor *const parent) {
+  MYNTEYE_UNUSED(parent)
+  const ObjMat *input = Object::Cast<ObjMat>(in);
+  ObjMat *output = Object::Cast<ObjMat>(out);
+  cv::reprojectImageTo3D(input->value, output->value, Q_, true);
+  output->id = input->id;
+  return true;
+}
+
+MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/points_processor.h

@@ -0,0 +1,46 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef MYNTEYE_API_PROCESSOR_POINTS_PROCESSOR_H_
+#define MYNTEYE_API_PROCESSOR_POINTS_PROCESSOR_H_
+#pragma once
+
+#include <string>
+
+#include <opencv2/core/core.hpp>
+
+#include "mynteye/api/processor.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+class PointsProcessor : public Processor {
+ public:
+  static const char NAME[];
+
+  explicit PointsProcessor(cv::Mat Q, std::int32_t proc_period = 0);
+  virtual ~PointsProcessor();
+
+  std::string Name() override;
+
+ protected:
+  Object *OnCreateOutput() override;
+  bool OnProcess(
+      Object *const in, Object *const out, Processor *const parent) override;
+
+ private:
+  cv::Mat Q_;
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_API_PROCESSOR_POINTS_PROCESSOR_H_

src/mynteye/api/processor/rectify_processor.cc

@@ -0,0 +1,98 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "mynteye/api/processor/rectify_processor.h"
+
+#include <utility>
+
+#include <opencv2/calib3d/calib3d.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include "mynteye/logger.h"
+#include "mynteye/device/device.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+const char RectifyProcessor::NAME[] = "RectifyProcessor";
+
+RectifyProcessor::RectifyProcessor(
+    std::shared_ptr<Device> device, std::int32_t proc_period)
+    : Processor(std::move(proc_period)) {
+  VLOG(2) << __func__ << ": proc_period=" << proc_period;
+  InitParams(
+      device->GetIntrinsics(Stream::LEFT), device->GetIntrinsics(Stream::RIGHT),
+      device->GetExtrinsics(Stream::RIGHT, Stream::LEFT));
+}
+
+RectifyProcessor::~RectifyProcessor() {
+  VLOG(2) << __func__;
+}
+
+std::string RectifyProcessor::Name() {
+  return NAME;
+}
+
+Object *RectifyProcessor::OnCreateOutput() {
+  return new ObjMat2();
+}
+
+bool RectifyProcessor::OnProcess(
+    Object *const in, Object *const out, Processor *const parent) {
+  MYNTEYE_UNUSED(parent)
+  const ObjMat2 *input = Object::Cast<ObjMat2>(in);
+  ObjMat2 *output = Object::Cast<ObjMat2>(out);
+  cv::remap(input->first, output->first, map11, map12, cv::INTER_LINEAR);
+  cv::remap(input->second, output->second, map21, map22, cv::INTER_LINEAR);
+  output->first_id = input->first_id;
+  output->second_id = input->second_id;
+  return true;
+}
+
+void RectifyProcessor::InitParams(
+    Intrinsics in_left, Intrinsics in_right, Extrinsics ex_right_to_left) {
+  cv::Size size{in_left.width, in_left.height};
+
+  cv::Mat M1 =
+      (cv::Mat_<double>(3, 3) << in_left.fx, 0, in_left.cx, 0, in_left.fy,
+       in_left.cy, 0, 0, 1);
+  cv::Mat M2 =
+      (cv::Mat_<double>(3, 3) << in_right.fx, 0, in_right.cx, 0, in_right.fy,
+       in_right.cy, 0, 0, 1);
+  cv::Mat D1(1, 5, CV_64F, in_left.coeffs);
+  cv::Mat D2(1, 5, CV_64F, in_right.coeffs);
+  cv::Mat R =
+      (cv::Mat_<double>(3, 3) << ex_right_to_left.rotation[0][0],
+       ex_right_to_left.rotation[0][1], ex_right_to_left.rotation[0][2],
+       ex_right_to_left.rotation[1][0], ex_right_to_left.rotation[1][1],
+       ex_right_to_left.rotation[1][2], ex_right_to_left.rotation[2][0],
+       ex_right_to_left.rotation[2][1], ex_right_to_left.rotation[2][2]);
+  cv::Mat T(3, 1, CV_64F, ex_right_to_left.translation);
+
+  VLOG(2) << "InitParams size: " << size;
+  VLOG(2) << "M1: " << M1;
+  VLOG(2) << "M2: " << M2;
+  VLOG(2) << "D1: " << D1;
+  VLOG(2) << "D2: " << D2;
+  VLOG(2) << "R: " << R;
+  VLOG(2) << "T: " << T;
+
+  cv::Rect left_roi, right_roi;
+  cv::stereoRectify(
+      M1, D1, M2, D2, size, R, T, R1, R2, P1, P2, Q, cv::CALIB_ZERO_DISPARITY,
+      0, size, &left_roi, &right_roi);
+
+  cv::initUndistortRectifyMap(M1, D1, R1, P1, size, CV_16SC2, map11, map12);
+  cv::initUndistortRectifyMap(M2, D2, R2, P2, size, CV_16SC2, map21, map22);
+}
+
+MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/rectify_processor.h

@@ -0,0 +1,55 @@
+// Copyright 2018 Slightech Co., Ltd. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef MYNTEYE_API_PROCESSOR_RECTIFY_PROCESSOR_H_
+#define MYNTEYE_API_PROCESSOR_RECTIFY_PROCESSOR_H_
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <opencv2/core/core.hpp>
+
+#include "mynteye/types.h"
+#include "mynteye/api/processor.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+class Device;
+
+class RectifyProcessor : public Processor {
+ public:
+  static const char NAME[];
+
+  RectifyProcessor(
+      std::shared_ptr<Device> device, std::int32_t proc_period = 0);
+  virtual ~RectifyProcessor();
+
+  std::string Name() override;
+
+  cv::Mat R1, P1, R2, P2, Q;
+  cv::Mat map11, map12, map21, map22;
+
+ protected:
+  Object *OnCreateOutput() override;
+  bool OnProcess(
+      Object *const in, Object *const out, Processor *const parent) override;
+
+ private:
+  void InitParams(
+      Intrinsics in_left, Intrinsics in_right, Extrinsics ex_right_to_left);
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_API_PROCESSOR_RECTIFY_PROCESSOR_H_