原文：OpenCV Android Programming By Example

协议：CC BY-NC-SA 4.0

译者：飞龙

本文来自【ApacheCN 计算机视觉译文集】，采用译后编辑（MTPE）流程来尽可能提升效率。

当别人说你没有底线的时候，你最好真的没有；当别人说你做过某些事的时候，你也最好真的做过。

一、准备就绪

在本章中，我将逐步介绍如何开始使用 OpenCV 开发具有视觉感知的 Android 应用。

开源计算机视觉（OpenCV）软件库具有 2500 多种优化算法；该库包括一整套经典和最先进的计算机视觉和机器学习算法。它已经存在了十年，并根据伯克利软件发行（BSD）许可证发布，使用户易于使用和修改。

OpenCV 被下载了超过 700 万次，并被 Google，Yahoo，Microsoft，Intel，IBM，Sony 和 Honda 等知名公司使用。此外，OpenCV 支持多种桌面和移动操作系统，包括 Windows，Linux，Mac OSX，Android 和 iOS。

在本书中，我们将使用适用于 Android 的 OpenCV，它是可在 Android 操作系统上运行的 OpenCV 的一部分。

我将介绍两种安装和准备方案。首先，如果您要开始全新安装 Android，建议您从 Tegra Android 开发包（TADP）开始。另一种情况是手动安装运行 OpenCV 的 Android 所需的每个组件。如果您先前已经安装了 Android 开发环境，则可能会选择此选项。我们将涵盖以下主题：

安装 Tegra Android 开发包
手动安装 OpenCV 和 Android 开发环境
了解本机开发套件（NDK）的工作方式
使用 OpenCV 构建您的第一个 Android 项目

安装 Tegra Android 开发包

NVIDIA 发布了 TADP ，以使 Android 开发环境的准备工作变得无缝。

NVIDIA 已发布 TADP 3.0r4 版本，以支持 Android SDK（23.0.2），NDK（r10c）和 OpenCV for Tegra 2.4.8.2，这是一个常规的 OpenCV4Android SDK，已通过 Tegra 特定的优化进行了扩展。

下载并安装 TADP

要获取 TADP，请访问这个页面并按照步骤成为注册开发者；它是免费会员。

激活成员身份后，登录并下载与您的操作系统相对应的版本。 NVIDIA 支持以下操作系统：

Windows 64 位
Mac OSX
Ubuntu Linux（32/64 位）

就我而言，我的计算机上装有 Windows 7 64 位，因此从现在开始，所有后续步骤都经过了测试，并且在此操作系统上运行良好。但是，如果您使用其他操作系统，我预计不会有任何重大变化。

注意

对于 Ubuntu 安装，TADP 将需要您具有root特权，因此请确保您具有。

下载完 TADP 安装程序后，启动它并执行以下步骤：

阅读并接受许可协议后，请按照屏幕上的说明进行操作。
您将需要选择安装类型。选择“自定义”安装，然后单击“下一步”按钮：
如图所示，选择要安装的组件，然后单击“下一步”按钮：
您需要命名安装并下载目录。

注意

请注意，如果您以前安装过，则会收到一条警告消息，提示您需要卸载以前的安装。要卸载先前的安装，请转到先前的安装目录并运行tadp_uninstall.exe。

有时，卸载程序无法清除所有内容。在这种情况下，您需要手动删除先前安装目录的内容。
现在，您可以安装选定的组件了。单击Next按钮。
如果您在代理后面，则可以输入代理详细信息；否则，单击Next按钮。
安装程序将开始下载所有选定的组件。这可能需要一段时间，具体取决于您的互联网连接。
下载完成后，单击“下一步”以开始安装所选组件。

注意

有时，安装程序窗口将不响应。没关系，几分钟后，安装将以正常方式继续。
选择所需的安装后操作，然后单击完成按钮。

TADP 安装后配置

是的，TADP 将为您下载并安装所有内容；但是，您仍然需要进行一些安装后配置，以确保一切正常。

安装仿真器系统映像

如果您想以该 SDK 平台为目标运行仿真器，则需要为安装的每个 Android SDK 平台安装一个系统映像。

为此，只需遵循以下简单步骤：

转到在安装 TADP 时选择的安装目录。
打开 SDK 文件夹；在这种情况下，它是android-sdk-windows。
运行 SDK Manager。
对于每个已安装的 AndroidX.X，为模拟器选择一个系统映像，例如 ARM EABI V7a 系统映像：
单击安装包。
阅读并接受所选组件的许可协议。
单击安装。

现在，您可以在任何已安装目标的仿真器上测试应用。

配置 Eclipse 以与 NDK 一起使用

您还需要配置 Eclipse 以使其与 NDK 一起运行，以便您可以直接从 Eclipse 构建本机应用：

从先前指定的安装目录启动 Eclipse。
打开窗口 | 首选项。
在左侧窗格中，打开 Android 树。
选择标记为 NDK 的树节点。
在右窗格中，单击浏览并选择 NDK 目录；您将在安装目录下找到它。
单击Next。

NDK 验证

由于 OpenCV 库是用 C/C++ 编写的，因此，验证您的环境是否正常运行的第一步是确保您能够运行使用本机代码的 Android 应用：

启动 Eclipse。
从 NDK 安装目录（在我的情况下为C:\NVPACK\android-ndk-r10c\），从samples文件夹中导入hello-jni示例项目，就像要导入任何其他 Android 项目一样。
右键单击HelloJni项目。
在上下文菜单中，选择 Android 工具 | 添加本机支持。
确保将库名称设置为hello-jni；默认情况下，应将其命名为此。
用您选择的目标启动仿真器。
右键单击项目浏览器中的hello-jni项目。在上下文菜单中，选择运行为 | Android 应用。

在控制台输出中，应该有.so文件的列表；这些是 NDK 使用应用二进制接口（ABI）构建的本机共享库，该库确切定义了机器代码的外观。

Android NDK 支持不同的架构。默认情况下，如果在application.mk文件中指定了.so，则除了 MIPS 和 x86 之外，还将为 ARM EABI 生成.so。我们将在本章后面讨论这个主题。

如果一切运行顺利，则您的模拟器应具有一个运行如下的应用：

NDK verification

该应用非常简单，是一个很好的检查点，它可以验证您是否可以从 Android 应用调用本机代码。

基本上，您在模拟器屏幕上看到的是从本机代码返回并由 Android 框架在文本视图中显示的字符串。

手动安装 OpenCV 和 Android 开发环境

要选择手动安装 OpenCV 和 Android 开发环境，您的计算机上可能已安装了以下组件：

Java SE 开发套件 6
Android Studio
Android SDK
Eclipse IDE
Eclipse 的 ADT 和 CDT 插件
Android NDK
OpenCV4Android SDK

您可以按照手动安装步骤进行操作，以确保已准备好并正确配置了所有需要的组件，以便开始使用 OpenCV 开发 Android 应用。

Java SE 开发套件 6

您可以从这个页面下载适用于您的 OS 的 JDK 安装程序。

Android Studio

另一个非常好的选项是 Android Studio。您可以从这个页面下载 Android Studio。请注意，Android Studio 与 Android SDK 捆绑在一起，因此如果使用此选项，则无需安装它。此外，您可以跳过 Eclipse 和 ADT 的安装，并注意从 Android Studio 1.3 开始；您还将找到对 NDK 的内置支持。

Android SDK

要下载并安装 Android SDK，请按照以下步骤操作：

访问这个页面。
向下滚动至仅 SDK 工具部分，然后单击 Windows 安装程序链接的.exe文件。
阅读并接受条款和条件后，请单击下载按钮。
将安装程序保存在磁盘上，然后单击.exe文件以启动安装程序，然后按照屏幕上的说明进行操作。
记下 SDK 目录，以便以后从命令行引用它。
安装完成后，Android SDK 管理器将启动。
选择安装 Android SDK 工具，版本 20 或更高版本。
对于 Android 的 SDK 平台，请选择 Android 3.0（API 11）或更高版本。就我而言，我使用了 API 15，建议您这样做。
阅读并接受许可协议，然后单击安装。

Eclipse IDE

对于 OpenCV 2.4。x，建议使用 Eclipse 3.7（Indigo）或 Eclipse 4.2（Juno）；您可以从 Eclipse 的官方网站下载您选择的版本。

用于 Eclipse 的 ADT 和 CDT 插件

假设您已经下载了 Eclipse，则可以按照以下步骤下载 Android 开发人员工具（ADT）和 C/C++ 开发工具（CDT）插件：

启动 Eclipse，然后导航至帮助 | 安装新软件。
单击右上角的添加按钮。
在添加存储库对话框中，在名称字段中写入ADT Plug-in，然后复制并粘贴此 URL，在位置字段中。
单击Next。
选中开发人员工具复选框。
单击Next。
下一个窗口将显示要下载的工具列表。只要确保它包含本机支持工具（CDT），然后单击Next。
阅读并接受许可协议，然后单击完成。
安装完成后，您将需要重新启动 Eclipse。

Android NDK

按照的要求为 C++ 开发 Android，您需要安装 Android NDK。

注意

并非要在所有情况下都使用 Android NDK。作为开发人员，您需要在使用本机 API 带来的性能提升与引入的复杂性之间取得平衡。

在我们的情况下，由于OpenCV库是用 C/C++ 编写的，因此我们可能必须使用 NDK。但是，不应仅仅因为程序员更喜欢用 C/C++ 编写代码而使用 NDK 。

下载 Android NDK

您可以按照以下步骤下载 Android NDK：

转到 Android NDK 主页。
在下载部分中，选择与您的操作系统相对应的版本。就我而言，它是 Windows 64 位。
阅读并同意条款和条件。
单击下载按钮。

安装和配置 Android NDK

下载完成后，您需要按照以下步骤配置 NDK：

导航至 NDK 下载文件夹。
双击下载的文件将其解压缩。
重命名并移动提取的文件夹；我将ndk文件夹称为<ndk_home>。现在，您可以使用 NDK 来构建项目了。
如果您希望从命令行进行构建，则需要将<ndk_home>文件夹（在我的情况下为C:/android/android-ndk-r10d）添加到PATH环境变量中。对于 Windows，请打开 CMD。输入以下命令，并将ndk目录替换为您的目录：
```
set PATH=%PATH%;c:/android/android-ndk-r10d
```
要检查 NDK 的配置是否正确，请转到包含项目的目录。为简单起见，您可以在hello-jni示例项目上进行测试。您可以在<ndk_home>/samples/下找到它。
通过执行命令cd <your_project_directory>/更改目录。运行以下命令：
```
ndk-build
```
如控制台输出所示，扩展名为.so的文件是此项目中使用的 C/C++ 源代码的编译版本：

使用 Eclipse 构建本机代码

如果您更喜欢从 Eclipse 构建，这更方便，则需要告诉 Eclipse 在哪里可以找到 NDK，以便可以构建应用：

启动 Eclipse 并打开窗口 | 首选项。
在左侧窗格中，打开 Android 树。
选择 NDK 树节点，然后在右侧窗格中单击浏览，然后选择<ndk_home>目录。
单击Next。
从<ndk_home>/samples/导入hello-jni示例项目作为 Android 项目。
打开项目资源管理器，然后右键单击hello-jni项目。
在上下文菜单中，导航到 Android 工具 | 添加本机支持将此项目转换为 C++ 项目。
接受默认的库名称，然后单击完成。
生成应用。

在控制台中，您将看到.so文件的列表，这些文件是此项目的已编译 C++ 部分。不过，如果您从导入的项目中打开任何 C/C++ 文件，您将看到许多突出显示的错误。您只需要执行一些与 CDT 插件相关的步骤：

导航到项目 | 属性。在左侧窗格中，展开 C/C++ 通用节点。
选择路径和符号。
在右侧窗格中，选择包括选项卡。
单击添加，然后单击文件系统添加以下路径：
- 如果您安装了 NDK r8 或更早版本：
  
  <ndk_home>/platforms/android-9/arch-arm/usr/include<ndk_home>/sources/cxx-stl/gnu-libstdc++/include<ndk_home>/sources/cxx-stl/gnu-libstdc++/libs/armeabi-v7a/include
- 如果您安装了 NDK r8b 或更高版本：
  
  <ndk_home> /platforms/android-9/arch-arm/usr/include
  
  <ndk_home>/sources/cxx-stl/gnu-libstdc++/4.6/include
  
  <ndk_home> /sources/cxx-stl/gnu-libstdc++/4.6/libs/armeabi-v7a/include
单击Next。 Eclipse 将重建项目，并且应从 Eclipse 中清除所有语法错误。
现在，您可以构建项目以将 Java 代码和本机代码打包在一个 APK 中。要将应用安装在您选择的仿真器上，请使用菜单项运行 | 运行方式为 | Android 应用。

OpenCV4Android SDK

为了能够在您的 Android 设备上使用本机（C/C++）库的 OpenCV 集合，您需要安装 OpenCV4Android SDK，它是 OpenCV 的一部分，可以在 Android 操作系统上运行。

首先，转到 OpenCV 下载页面。
下载最新可用版本，在撰写本书时为2.4.10。
将压缩文件解压缩到方便的路径，例如C:\opencv\。

注意

强烈建议使用无空格的路径，以避免ndk-build出现任何问题。

了解 NDK 的工作方式

无论您是使用 TADP 进行全新安装，还是按照手动设置步骤进行操作，在此阶段，您都应该具有开发视觉感知的 Android 应用所需的所有组件。

在继续我们的第一个示例之前，让我们先详细说明 NDK 的工作方式。熟悉 Android NDK 的基础知识并习惯使用它始终是一个好主意，因为它将成为我们使用 OpenCV 开发 Android 应用的基石。

NDK 概述

如果您决定使用命令提示符编译 Android 应用的本机部分，则必须使用ndk-build工具。 ndk-build工具实际上是一个脚本，它将启动负责以下内容的不同构建脚本：

它会自动搜索您的项目，以决定要构建什么
搜索完成后，脚本开始生成二进制文件并管理依赖项
它将生成的二进制文件复制到您的项目路径

除了ndk-build工具之外，您还应该熟悉其他一些主要组件，其中包括：

Java 和本机调用：Android 应用是用 Java 编写的，一旦源代码被编译，便会转换为字节码，以便 Android OS 在 Dalvik 或 Android 运行时（ART）下运行虚拟机。

注意

请注意，仅在 Dalvik 虚拟机上对执行本机代码的应用进行测试。

使用本机代码中实现的方法时，应使用native关键字。

例如，您可以声明一个将两个数字相乘的函数，并指示编译器它是本机库：
```
public native double mul(double x, double y);
```
本机共享库：NDK 使用扩展名.so构建这些库。顾名思义，这些库在运行时是共享和链接的。
本机静态库：NDK 也以扩展名.a来构建这些库；这类库实际上是在编译时链接的。
Java 本机接口（JNI）：在用 Java 编写 Android 应用时，您需要一种方式将调用引导到用 C/C++ 编写的本机库中， JNI 派上用场了。
应用二进制接口（ABI）：该接口定义了应用计算机代码的外观，因为您可以在不同的计算机架构上运行应用。默认情况下，NDK 为 ARM EABI 构建代码。但是，您也可以选择要为 MIPS 或 x86 构建的。
Android.mk：将此文件视为 Maven 生成脚本或更好的 Makefile，该文件指示ndk-build脚本有关模块的定义及其名称，编译所需的源文件，以及您需要链接的库。了解如何使用此文件非常重要，我们稍后将返回至更多信息。
Application.mk：创建此文件是可选的，用于列出您的应用所需的模块。该信息可以包括用于为特定目标架构，工具链和标准库生成机器代码的 ABI。

考虑到这些组件，您可以总结出为 Android 开发本机应用的一般流程，如下所示：

确定哪些部分将用 Java 编写，哪些部分将用本机 C/C++ 编写。
在 Eclipse 中创建一个 Android 应用。
创建一个Android.mk文件来定义您的模块，列出要编译的本机源代码文件，并枚举链接的库。
创建Application.mk；这是可选的。
将您的Anrdoid.mk文件复制到项目路径中的jni文件夹下。
使用 Eclipse 构建项目。当我们将 Eclipse 链接到已安装的 NDK 时，ndk-build工具将编译.so和.a库，您的 Java 代码将被编译为.dex文件，所有内容都将打包在一个 APK 文件中，准备安装。

NDK 的简单示例

当您开发具有本机支持的 Android 应用时，您需要熟悉使用 NDK 的典型 Android 应用的一般结构。

通常，您的 Android 应用具有以下文件夹结构。项目root文件夹具有以下子目录：

jni/
libs/
res/
src/
AndroidManifest.xml
project.properties

这里，与 NDK 相关的文件夹如下：

jni文件夹将包含应用的本机部分。换句话说，这是带有 NDK 构建脚本（例如Android.mk和Application.mk）的 C/C++ 源代码，它们是构建本机库所需的。
成功构建后，libs文件夹将包含本机库。

注意

NDK 构建系统需要AndroidManifest.xml和project.properties文件来编译应用的本机部分。因此，如果缺少这些文件中的任何一个，则需要先编译 Java 代码，然后再编译 C/C++ 代码。

`Android.mk`

在本节中，我将描述构建文件的语法。如前所述，Android.mk实际上是 GNU Makefile 片段，构建系统会对其进行解析以了解在项目中构建什么。该文件的语法允许您定义模块。模块是以下之一：

静态库
共享库
独立的可执行文件

您已经使用ndk-build来构建hello-jni项目，因此让我们看一下该项目Android.mk文件的内容：

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE    := hello-jni
LOCAL_SRC_FILES := hello-jni.c

include $(BUILD_SHARED_LIBRARY)

现在，让我们一一介绍这些行：

LOCAL_PATH := $(call my-dir)：这里，脚本定义了一个名为LOCAL_PATH的变量，并通过调用my-dir函数设置其值，该函数返回当前工作目录。
include $(CLEAR_VARS)：在此行中，脚本包含另一个名为CLEAR_VARS的 GNU Makefile，用于清除所有局部变量-以Local_XXX开头的变量，但LOCAL_PATH除外。这是必需的，因为构建文件是在单执行执行上下文中解析的，其中所有变量都声明为全局变量。
LOCAL_MODULE := hello-jni：在这里，脚本定义了一个名为hello-jni的模块。必须定义 LOCAL_MODULE变量，并且该变量是唯一的，以标识Android.mk中的每个模块。

注意

构建系统将在您定义的模块中添加lib前缀和.so后缀。在示例情况下，生成的库将被命名为libhello-jni.so。
LOCAL_SRC_FILES := hello-jni.c：顾名思义，您将在一个模块中列出所有需要构建和组装的源文件。

注意

您仅列出源文件，而不列出头文件；构建系统负责为您计算依赖关系。
include $(BUILD_SHARED_LIBRARY)：这里包括另一个 GNU Makefile，它将收集您在最后一个include 命令之后定义的所有信息，并确定要构建的内容以及如何构建模块。

使用 OpenCV 构建您的第一个 Android 项目

在开发环境启动并运行并且具有适当的 NDK 背景的情况下，我可以开始组装如何在 Android 应用中使用 OpenCV 库的全景图。

适用于 Android 的 OpenCV 支持通过其本地 API 和 Java 包装 API 访问其功能。对于本机 API，您将使用 Android NDK 定义本机库，并包含您正在使用的 OpenCV 库。然后，您将使用 Java 本机接口（JNI）从 Java 代码调用本机库。

另一个选择是使用常规的 Java 导入直接在 Java 代码中使用 OpenCV Java 包装器。将会发生的是，Java 包装器将使用 JNI 将您的调用引导至本机 OpenCV 库。

当然，取决于您选择哪种样式。但是，您应该理解，使用本机调用可以减少 JNI 开销，但需要更多的编程工作。另一方面，使用 Java 包装器可能会导致较少的编程工作而导致更多的 JNI 开销。

注意

考虑这种情况：您正在处理视频帧或静止图像，并且在您的算法中，您将调用几个 OpenCV 函数。在这种情况下，最好编写一个调用所有这些函数的本机库。在您的 Android 应用中，您只能使用一个 JNI 调用来访问此本机库。

`HelloVisionWorld` Android 应用

我们将构建我们的第一个 Android 应用，以从相机实时获取预览帧，并使用 OpenCV 的 Java 相机 API 在全屏上显示预览。

在 Eclipse 中创建项目

之后是在 Eclipse 中创建项目的步骤：

启动 Eclipse 并创建一个新的工作区。
创建一个新的 Android 项目，并将您的应用命名为HelloVisionWorld。
设置最低 SDK 版本。要使用 OpenCV4Android SDK 进行构建，最低 SDK 版本为 11；但是，强烈建议使用 API 15 或更高版本。就我而言，我使用了 API 15。
选择目标 SDK。就我而言，我将其设置为 API 19。单击Next。
允许 Eclipse 创建新的空白活动，并使用名为activity_hello_vision的布局将其命名为HelloVisionActivity。
将OpenCV库项目导入到您的工作区中。导航到文件 | 导入 | 现有的 Android 代码到工作区中。
选择 OpenCV4Android SDK 的root目录。 取消全选示例项目，仅选择OpenCV Library，然后单击Finish：
从您的 Android 项目中引用 OpenCV 库。点击项目 | 属性。从左侧窗格中选择“Android”树节点，然后在右侧窗格中，在“库”部分中单击“添加”，然后单击“确定”：

在 Android Studio 中创建项目

之后是在 Android Studio 中创建项目的步骤：

启动 Android Studio。
创建一个新的 Android Studio 项目，并将其命名为HelloVisionWorld，并将公司域设置为app0.com。
选择最小 SDK。要使用 OpenCV4Android SDK 进行构建，最低 SDK 版本为11。
创建一个空白活动并将其命名为HelloVisionActivity。
要将OpenCV作为依赖项添加到您的项目，请导航至文件 | 新增 | 导入模块和<OpenCV4Android_Directoy>\sdk\java。然后，单击OK。此时，取决于从 Android SDK 安装的组件，您可能会遇到一些问题。 Android Studio 将提出快速修复链接来解决此类错误，这应该是一个简单的修复方法。
在项目视图中右键单击新创建的应用，然后选择打开模块设置或按F4。
在依赖项选项卡中，按+按钮，然后选择模块依赖项。
选择 OpenCV 库，然后按添加。现在，您应该能够将 OpenCV 类导入到您的项目中了。

继续前进，无论选择哪种 IDE，您都应该能够按照以下步骤操作：

打开layout文件并对其进行编辑以匹配以下代码。我们添加了 OpenCV 命名空间，并定义了 Java 摄像机视图布局：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:opencv="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.example.hellovisionworld.HelloVisionActivity" >
    <org.opencv.android.JavaCameraView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:visibility="gone"
        android:id="@+id/HelloVisionView"
        opencv:show_fps="true"
        opencv:camera_id="any" />
</RelativeLayout>

注意

下载示例代码

您可以从这个页面下载从帐户购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了此书，则可以访问这个页面并进行注册，以便将文件直接通过电子邮件发送给您。

由于我们将使用设备相机进行，因此我们需要在AndroidManifest文件中设置一些权限：

</application>

<uses-permission android:name="android.permission.CAMERA"/>

<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>

在AndroidManifest文件中隐藏标题和系统按钮：

<application
    android:icon="@drawable/icon"
    android:label="@string/app_name"
    android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >

我们需要在创建的活动中初始化 OpenCV 库。为此，我们使用 OpenCV Manager 服务使用异步初始化来访问外部安装在目标系统中的 OpenCV 库。首先，我们需要在将要使用的仿真器上安装 OpenCV Manager。为此，请在命令提示符下使用adb install命令：

adb install <OpenCV4Android SDK_Home>\apk\OpenCV_2.4.X_Manager_2.X_<platform>.apk

用您的 OpenCV 安装文件夹替换<OpenCV4Android SDK_Home>，用apk文件夹中的可用版本替换apk名称中的X。

对于<platform>，请使用下表根据仿真器上安装的系统映像选择要安装的平台：

硬件平台	包名字
armeabi-v7a（ARMv7-A +霓虹灯）	`OpenCV_2.4.X_Manager_2.X_armv7a-neon.apk`
armeabi（ARMv5，ARMv6）	`OpenCV_2.4.X_Manager_2.X_armeabi.apk`
英特尔 x86	`OpenCV_2.4.X_Manager_2.X_x86.apk`
MIPS	`OpenCV_2.4.X_Manager_2.X_mips.apk`

注意

在真实设备上测试应用时，将显示一条消息，要求您从 Google Play 下载 OpenCV 管理器，因此请单击是并检查其支持的 OpenCV 版本，以便您可以通过异步初始化来加载它。

在Activity中，定义以下内容并相应地修复导入：

//A Tag to filter the log messages
private static final String  TAG = "Example::HelloVisionWorld::Activity";

//A class used to implement the interaction between OpenCV and the //device camera.
private CameraBridgeViewBase mOpenCvCameraView;

//This is the callback object used when we initialize the OpenCV //library asynchronously
private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {

    @Override
       //This is the callback method called once the OpenCV //manager is connected
    public void onManagerConnected(int status) {
      switch (status) {
  //Once the OpenCV manager is successfully connected we can enable the camera interaction with the defined OpenCV camera view
      case LoaderCallbackInterface.SUCCESS:
        {
          Log.i(TAG, "OpenCV loaded successfully");
          mOpenCvCameraView.enableView();
        } break;
          default:
            {
              super.onManagerConnected(status);
            } break;
       }
    }
};

更新onResume活动回调方法以加载 OpenCV 库并相应地修复导入：

@Override
public void onResume(){

  super.onResume();

//Call the async initialization and pass the callback object we //created later, and chose which version of OpenCV library to //load. Just make sure that the OpenCV manager you installed //supports the version you are trying to load.
  OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_10, this, mLoaderCallback);
}

您的活动需要实现CvCameraViewListener2，才能从 OpenCV 摄像机视图接收摄像机帧：
```
public class HelloVisionActivity extends Activity implements CvCameraViewListener2
```
相应地修复导入错误，并在您的活动中插入未实现的方法。

在onCreate活动回调方法中，我们需要将 OpenCV 摄像机视图设置为可见，并且将您的活动注册为将处理摄像机帧的回调对象：

@Override
protected void onCreate(Bundle savedInstanceState) {
  Log.i(TAG, "called onCreate");

  super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  setContentView(R.layout.activity_hello_vision);

  mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.HelloVisionView);

  //Set the view as visible
  mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);

  //Register your activity as the callback object to handle //camera frames
  mOpenCvCameraView.setCvCameraViewListener(this);
}

最后一步是接收摄像机帧。为此，请更改onCameraFrame回调方法的实现：

```java
public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

  //We're returning the colored frame as is to be rendered on //thescreen.
  return inputFrame.rgba();
}
```

现在，您可以在模拟器或真实设备上构建和安装应用了。
这是在仿真相机上运行的应用：

![Creating a project in Android Studio](https://img-blog.csdnimg.cn/img_convert/e65df8cd175c80ce60243e2f738b739e.png)

总结

到目前为止，您应该已经开发并测试了您的第一个可感知视觉的 Android 应用。在本章中，您学习了如何使用 TADP 通过 OpenCV 设置 Android 开发环境，或者通过手动方案更新现有环境。

此外，您已经了解了 NDK 的基础知识及其工作方式。最后，您已经了解了如何使用 OpenCV 摄像机视图捕获摄像机帧并将其显示在设备屏幕上。此示例将成为我们实现更多有趣构想的基础。

二、应用 1-建立自己的暗室

在本章中，您将学习如何在 OpenCV 中存储和表示图像，以及如何利用这种表示来实现有趣的算法，这些算法将增强图像的外观。

我们将首先解释数字图像表示和不同的色彩空间，以探索 OpenCV 中重要的Mat类。

然后，我们将逐步执行从手机图库加载图像并将其显示在设备屏幕上的操作，而不管图像分辨率如何。

最后，您将了解图像直方图，以及如何计算和使用它们来增强图像（无论是黑白图像还是彩色图像）。

我们将在本章介绍以下主题：

数码图像
处理手机中存储的图像
计算图像直方图
增强图像对比度

数码图像

无论我们在哪里，都可以在我们周围找到图片；因此，如果我们想自动理解，处理和分析这些图像，那么了解图像的表示方式以及图像的颜色映射是非常重要的。

色彩空间

我们生活在一个连续的世界中，因此要在离散的数字传感器中捕获场景，就必须进行离散的空间（布局）和强度（颜色信息）映射，以便将真实世界的数据存储在数字图像中。

二维数字图像D(i, j)从左上开始代表在由行号i和列号j表示的像素处的传感器响应值，角为i = j = 0。

为了表示颜色，数字图像通常包含一个或多个通道来存储每个像素的强度值（颜色）。使用最广泛的颜色表示法是单通道图像，也称为灰度图像，其中根据像素的强度值为每个像素分配灰色阴影：零是黑色，最大强度是白色。

如果使用从 0 到2^8 - 1的值的无符号字符表示色深信息，则每个像素可以存储从 0（黑色）到 255（白色）的强度值。

除了灰度颜色映射外，还有真彩色映射，其中颜色由三个通道而不是一个通道表示，并且像素值变为三个元素（红色，绿色和蓝色）的元组。在这种情况下，颜色表示为三个通道值的线性组合，并且图像被视为三个二维平面。

注意

有时，添加了名为 Alpha 的第四个通道，用于表示颜色透明度。在这种情况下，图像将被视为四个二维平面。

与 RGB 表示相比，要考虑的色彩空间与人类对颜色的理解和感知更相关。它是色相，饱和度和值（HSV）色彩空间。

每个颜色尺寸可以理解如下：

色相（H）：它是颜色本身，红色，蓝色或绿色。
饱和度（S）：它测量颜色的纯度；例如，它是暗红色还是暗红色？可以想象一下，多少白色遮住了颜色。
值（V）：它是颜色的亮度，也称为亮度。

最后要考虑的图像类型是二进制图像。它是像素的二维数组。但是，每个像素只能存储零或一的值。这种类型或表示形式对于解决视觉问题（例如边缘检测）很重要。

具有像素的二维数组或三个二维平面来表示图像，其中每个单元或像素在 RGB 颜色空间的情况下包含颜色的强度值，在情况下包含色相，饱和度和值 HSV 色彩空间的大小，将图像缩小为数值矩阵。由于 OpenCV 的主要重点是处理和操纵图像，因此您需要了解的第一件事是 OpenCV 如何存储和处理图像。

`Mat`类

在使用 OpenCV 开发视觉感知应用时，将使用的最重要的基本数据结构是Mat类。

Mat类表示n维密集数字单通道或多通道数组。基本上，如果您使用Mat类表示灰度图像，则Mat对象将是存储像素强度值的二维数组（具有一个通道）。如果使用Mat类存储全彩色图像，则Mat对象将是具有三个通道的二维数组（一个通道用于红色强度，一个通道用于绿色，一个通道用于蓝色），并且同样适用 HSV 颜色空间。

与任何 Java 类一样，Mat类具有构造器列表，并且在大多数情况下，默认构造器就足够了。但是，在某些其他情况下，您可能希望使用特定的大小，类型和通道数来初始化Mat对象。

在这种情况下，可以使用以下构造器：

int numRow=5;
int numCol=5;
int type=org.opencv.core.CvType.CV_8UC1;
Mat myMatrix=newMat(numRow,numCol,type);

该构造器采用三个整数参数：

int Rows：新矩阵行的数量
int Cols：新矩阵列的数量
int type：新矩阵类型

注意

为了指定Mat类存储的类型以及有多少个通道，OpenCV 为您提供了CvType类和static int字段，并具有以下命名约定：

CV_[数据类型大小，8 | 16 | 32 | 64][有符号，无符号整数或浮点数，S | U | F][通道数，C1 | C2 | C3 | C4]

例如，您将类型参数指定为org.opencv.core.CvType.CV_8UC1；这意味着矩阵将通过一个通道保存 8 位无符号字符的颜色强度。换句话说，此矩阵将存储强度为 0（黑色）到 255（白色）的灰度图像。

基本`Mat`操作

除了了解数字图像在 OpenCV 库中的表示方式之外，您还需要熟悉可以在Mat对象上执行的一些基本操作。

您可以执行的最基本操作是像素级访问，以检索像素值，无论您的色彩空间是灰度级还是全 RGB。假设您具有第 1 章，“就绪”的应用，并且已启动并运行，您可以回想起在onCameraFrame()回调方法中，我们正在使用inputFrame.rgba()方法检索全彩色相机帧。

使用相机帧，我们可以使用以下代码访问像素值：

@Override
  public Mat onCameraFrame(CvCameraViewFrameinputFrame) {
    Mat cameraFram=inputFrame.rgba();
    double [] pixelValue=cameraFram.get(0, 0);
    double redChannelValue=pixelValue[0];
    double greenChannelValue=pixelValue[1];
    double blueChannelValue=pixelValue[2];
    Log.i(TAG, "red channel value: "+redChannelValue);
    Log.i(TAG, "green channel value: "+greenChannelValue);
    Log.i(TAG, "blue channel value: "+blueChannelValue);
    return inputFrame.rgba();
  }

让我们浏览重要的几行，其余的实际上很简单：

double [] pixelValue=cameraFram.get(0, 0);

在这一行中，我们调用get(0,0)函数并将其传递给行和列索引；在这种情况下，它是左上方的像素。

请注意，get()方法返回一个双精度数组，因为Mat对象最多可以容纳四个通道。

在我们的示例中，它是全彩色图像，因此除了一个透明度通道 Alpha（a）外，每个像素的红色（r），绿色（g）和蓝色（b）颜色通道的强度都将不同，因此该方法的名称为rgba()。

您可以使用数组索引运算符[]独立访问每个通道强度，因此对于红色，绿色和蓝色强度，分别使用0，1和2：

double redChannelValue=pixelValue[0];
double greenChannelValue=pixelValue[1];
double blueChannelValue=pixelValue[2];

下表列出了您需要熟悉的基本Mat类操作：

功能	代码样例
检索通道数	`Mat myImage; //declared and initialized`
	`int numberOfChannels=myImage.channels();`
制作包括矩阵数据在内的`Mat`对象的深层副本	`Mat newMat=existingMat.clone();`
检索矩阵列数	第一种方法：`Mat myImage; //declared and initialized`
	`int colsNum=myImage.cols();`
	第二种方法：`int colsNum=myImage.width();`
	第三种方法：`//And yes, it is a public instance variable.`
	`int colsNum=myImage.size().width;`
检索矩阵行数	第一种方法：`Mat myImage; //declared and initialized`
	`int rowsNum=myImage.rows();`
	第二种方法：`int rowsNum=myImage.height();`
	第三种方法：`//And yes, it is a public instance variable.`
	`int rowsNum=myImage.size().height;`
要检索矩阵元素深度（每个通道的类型）：	`Mat myImage; //declared and initialized`
	`int depth=myImage.depth()`
	`CV_8U`：8 位无符号整数（0 到 255）
	`CV_8S`：8 位有符号整数（-128 至 127）
	`CV_16U`：16 位无符号整数（0 到 65,535）
	`CV_16S`：16 位有符号整数（-32,768 至 32,767）
	`CV_32S`：32 位有符号整数（-2,147,483,648 至 2,147,483,647）
	`CV_32F`：32 位浮点数
	`CV_64F`：64 位浮点数
检索矩阵元素的总数（图像中的像素数）	`Mat myImage; //declared and initialized`
	`long numberOfPixels=myImage.total()`

处理手机中存储的图像

在本部分中，您将学习如何从手机上加载图像并对其应用一些有趣的图像处理算法，例如对比度增强，平滑（消除图像中的噪声）以及应用一些过滤器。

将图像加载到`Mat`对象

首先创建一个新的 Android 项目，让我们开始。正如您在上一章中看到的一样，为了开始使用 OpenCV 算法，您需要将 OpenCV 库添加到您的项目中：

启动 Eclipse。
创建一个新的 Android 项目应用；我们命名为DarkRoom。
选择包名称。在此示例中，我将其选择为com.example.chapter2.darkroom。
将所需的最低 SDK 设置为 API 11（Android 3.0）以上。就我而言，强烈建议将其选择为 API 16（Android 4.1）。对于目标 SDK，应该选择 API 19，因为如果使用的目标 SDK 高于 19，则在加载 OpenCV 库时会出现问题。
单击Next。
让 Eclipse 为您创建一个空白活动并将其命名为IODarkRoom。
完成创建项目。
将 OpenCV 库项目导入到您的工作区文件中，菜单 | 导入 | 现有的 Android 代码到工作区。
单击浏览并转到您的 OpenCV 安装主目录。
选择 OpenCV 主目录，然后单击Next。
取消选择所有项目，然后仅选择 OpenCV 库项目。
点击完成。
现在，您需要将新创建的 Android 项目与刚刚导入的 OpenCV 库链接，因此，在新项目上，右键单击属性。
在左窗格中，选择Android树节点，然后在右窗格中，单击添加。
选择 OpenCV 库，然后单击Next。

UI 定义

在此项目中，您将加载手机中存储的图像，将其转换为位图图像，并在图像视图中显示。

让我们从设置应用活动的布局开始：

<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="horizontal">
  <ImageView
  android:id="@+id/IODarkRoomImageView"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:src="@drawable/ic_launcher"
  android:layout_marginLeft="0dp"
  android:layout_marginTop="0dp"
  android:scaleType="fitXY"/>
</LinearLayout>

这是带有图像视图的简单线性布局。下一步是设置一些所需的权限。万一您要从 SD 卡加载图像，则需要设置相应的权限，以便 Android 允许您的应用从外部存储设备进行读取和写入。

在清单文件中，添加以下行：

<uses-permissionandroid:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

这是写权限；但是，您的应用也被隐式授予读取权限，因为它的限制较少。

现在，让我们继续进行应用和活动的定义：

<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">
  <activity
  android:name=".IODarkRoom"
  android:label="@string/app_name"
  android:screenOrientation="portrait">
    <intent-filter>
      <actionandroid:name="android.intent.action.MAIN"/>

      <categoryandroid:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
  </activity>
</application>

这是一个非常简单的定义；但是，在不失一般性的前提下，我将活动的方向限制为纵向，这意味着您的活动将不支持横向模式。这将把重点放在图像处理上，而不是处理不同的活动模式。但是，我建议您在精读本章内容之后，将该应用扩展为也支持横向定位，因为它将为您带来良好的动手经验。

对于应用中将支持的每个操作，我们将需要一个菜单项。我们的第一个动作是在手机上打开图库，以选择特定的图像，为此，您需要在文件中添加以下菜单项：

res/menu/iodark_room.xml
<item
android:id="@+id/action_openGallary"
android:orderInCategory="100"
android:showAsAction="never"
android:title="@string/action_OpenGallary"/>

将相应的字符串定义添加到res/values/strings.xml：

<stringname="action_OpenGallary">Open Gallary</string>

我们已经完成了针对应用这一部分的 UI 定义，因此让我们继续其后的代码。

使用 OpenCV 读取图像

第一步是使用 OpenCV 管理器服务来异步加载 OpenCV 库，以减少应用的内存占用。为此，在将要使用 OpenCV 算法的每个活动中都需要具有以下样板代码：

private BaseLoaderCallback mLoaderCallback = newBaseLoaderCallback(this) {
  @Override
  public void onManagerConnected(int status) {
    switch (status) {
      case LoaderCallbackInterface.SUCCESS:
      {
        Log.i(TAG, "OpenCV loaded successfully");
      } break;
      default:
      {
        super.onManagerConnected(status);
      } break;
    }
  }
};

@Override
  public void onResume()
  {
    super.onResume();
    OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_8, this, mLoaderCallback);
  }

下一步是处理用户对我们之前定义的菜单项的单击：

private static final int SELECT_PICTURE = 1;
private String selectedImagePath;
@Override
  public boolean onOptionsItemSelected(MenuItem item) {
    // Handle action bar item clicks here. The action bar will
    // automatically handle clicks on the Home/Up button, so long
    // as you specify a parent activity in AndroidManifest.xml.
    int id = item.getItemId();
    if (id == R.id.action_openGallary) {
      Intent intent = newIntent();
      intent.setType("https://gitcode.net/apachecn/apachecn-cv-zh/-/raw/master/docs/opencv-android-prog-example/img/*");
      intent.setAction(Intent.ACTION_GET_CONTENT);
      startActivityForResult(Intent.createChooser(intent,"Select Picture"), SELECT_PICTURE);
      return true;
    }
    return super.onOptionsItemSelected(item);
  }

用户选择要从图库中加载的图像后，我们将执行加载并将其显示在活动结果回调方法中：

public void onActivityResult(int requestCode, int resultCode, Intent data) {
  if (resultCode == RESULT_OK) {
    if (requestCode == SELECT_PICTURE) {
      Uri selectedImageUri = data.getData();
 selectedImagePath = getPath(selectedImageUri);
      Log.i(TAG, "selectedImagePath: " + selectedImagePath);
 loadImage(selectedImagePath);
 displayImage(sampledImage);
    }
  }
}

在确保打开的活动返回了所需的结果（在本例中为图像 URI）之后，我们调用帮助程序方法getPath()来检索加载路径所需的格式的图像路径。使用 OpenCV 的图像：

private String getPath(Uri uri) {
  // just some safety built in 
  if(uri == null ) {
    return null;
  }
  // try to retrieve the image from the media store first
  // this will only work for images selected from gallery
  String[] projection = { MediaStore.Images.Media.DATA };
  Cursor cursor = getContentResolver().query(uri, projection, null, null, null);
  if(cursor != null ){
    int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
    cursor.moveToFirst();
    return cursor.getString(column_index);
  }
  return uri.getPath();
}

准备好路径后，我们将调用loadImage()方法：

private void loadImage(String path)
{
 originalImage = Highgui.imread(path);
  Mat rgbImage=new Mat();

 Imgproc.cvtColor(originalImage, rgbImage, Imgproc.COLOR_BGR2RGB);

  Display display = getWindowManager().getDefaultDisplay();
  //This is "android graphics Point" class
  Point size = new Point();
  display.getSize(size);

  int width = size.x;
  int height = size.y;
  sampledImage=new Mat();

 double downSampleRatio= calculateSubSampleSize(rgbImage,width,height);

 Imgproc.resize(rgbImage, sampledImage, new Size(),downSampleRatio,downSampleRatio,Imgproc.INTER_AREA);

  try {
    ExifInterface exif = new ExifInterface(selectedImagePath);
    int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

    switch (orientation)
    {
      case ExifInterface.ORIENTATION_ROTATE_90:
        //get the mirrored image
 sampledImage=sampledImage.t();
        //flip on the y-axis
 Core.flip(sampledImage, sampledImage, 1);
        break;
      case ExifInterface.ORIENTATION_ROTATE_270:
        //get up side down image
 sampledImage=sampledImage.t();
        //Flip on the x-axis
 Core.flip(sampledImage, sampledImage, 0);
        break;
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

让我们逐步看一下代码：

originalImage = Highgui.imread(path);

此方法从给定路径读取图像并返回它。它是Highgui类中的静态成员。

注意

如果要加载彩色图像，了解彩色通道的顺序非常重要。在imread()的情况下，解码的图像将具有按 B，G，R 顺序存储的通道。

现在，让我们看看以下代码片段：

Mat rgbImage=new Mat();

Imgproc.cvtColor(originalImage, rgbImage, Imgproc.COLOR_BGR2RGB);

为了将图像加载为 RGB 位图，我们首先需要将解码后的图像从颜色空间 B，G，R 转换为颜色空间 R，G，B。

首先，我们实例化一个空的Mat对象rgbImage，然后使用Imgproc.cvtColor()方法执行色彩空间映射。该方法采用三个参数：源图像，目标图像和映射代码。幸运的是，OpenCV 支持 150 多种映射，在我们的情况下，我们需要 BGR 到 RGB 映射。现在，让我们看看以下代码片段：

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);

int width = size.x;
int height = size.y;
double downSampleRatio= calculateSubSampleSize(rgbImage,width,height);

由于内存限制，以原始分辨率显示图像会非常浪费，有时甚至是不可能的。

例如，如果您使用手机的 8 百万像素相机拍摄了图像，则假设 1 字节的色深，彩色图像的存储成本为8 x 3(RGB) = 24 MB。

为解决此问题，建议将图像调整大小（缩小采样）至手机的显示分辨率。为此，我们首先获取手机的显示分辨率，然后使用calculateSubSampleSize()辅助方法计算下采样比率：

private static double calculateSubSampleSize(Mat srcImage, int reqWidth, int reqHeight) {
  // Raw height and width of image
  final int height = srcImage.height();
  final int width = srcImage.width();
  double inSampleSize = 1;

  if (height > reqHeight || width > reqWidth) {

    // Calculate ratios of requested height and width to the raw
    //height and width
    final double heightRatio = (double) reqHeight / (double) height;
    final double widthRatio = (double) reqWidth / (double) width;

    // Choose the smallest ratio as inSampleSize value, this will 
    //guarantee final image with both dimensions larger than or 
    //equal to the requested height and width.
    inSampleSize = heightRatio<widthRatio ? heightRatio :widthRatio;
  }
  return inSampleSize;
}

calculateSubSampleSize()方法采用三个参数：源图像，所需的宽度和所需的高度，然后计算下采样率。现在，让我们看看以下代码片段：

sampledImage=new Mat();
Imgproc.resize(rgbImage, sampledImage, new Size(),downSampleRatio,downSampleRatio,Imgproc.INTER_AREA);

现在，我们准备调整加载的图像的大小以适合设备屏幕。首先，我们创建一个空的Mat对象sampledImage，以保存调整大小后的图像。然后，我们将其传递给Imgproc.resize()：

源Mat对象，我们需要调整其大小
目标Mat对象
新图像的大小；在我们的例子中，一个新的空Size对象，因为我们将发送降采样率
X 方向上的下采样率的两倍（宽度）
Y 方向下采样率的两倍（高度）
插值方法的整数；默认值为INTER_LINEAR，它对应于线性插值

这里需要插值，因为我们将更改图像的大小（放大或缩小），并且我们希望从源图像到目标图像的映射尽可能平滑。

如果我们缩小尺寸，插值将决定目标图像像素的值在源图像的两个像素之间时是什么。如果我们正在扩大尺寸，它还将计算目标图像中新像素的值，而源图像中没有相应像素。

在这两种情况下，OpenCV 都有多个选项来计算此类像素的值。默认的INTER_LINEAR方法通过根据源像素与目标像素的接近程度对2 x 2周围源像素的值进行线性加权，来计算目标像素值。或者，INTER_NEAREST从源图像中最接近的像素获取目标像素的值。 INTER_AREA选项实际上将目标像素放在源像素上，然后平均覆盖的像素值。最后，我们可以选择在源图像的4×4周围像素之间拟合三次样条，然后从拟合的样条中读取相应的目标值；这是选择INTER_CUBIC内插方法的结果。

注意

要缩小图像，通常在INTER_AREA插值下看起来最好，而要放大图像，通常在INTER_CUBIC（慢）或INTER_LINEAR（更快，但仍然看起来不错）时看起来最好。

try {
  ExifInterface exif = new ExifInterface(selectedImagePath);
  int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

  switch (orientation)
  {
    case ExifInterface.ORIENTATION_ROTATE_90:
      //get the mirrored image
      sampledImage=sampledImage.t();
      //flip on the y-axis
      Core.flip(sampledImage, sampledImage, 1);
      break;
    case ExifInterface.ORIENTATION_ROTATE_270:
      //get upside down image
      sampledImage=sampledImage.t();
      //Flip on the x-axis
      Core.flip(sampledImage, sampledImage, 0);
      break;
  }
} catch (IOException e) {
  e.printStackTrace();
}

现在，我们需要来处理图像方向，并且由于该活动仅在纵向模式下有效，因此我们将以 90 或 270 度的旋转度处理图像。

在旋转 90 度的情况下，这意味着您将手机置于纵向时拍摄了图像；我们通过调用t()方法将图像逆时针旋转 90 度，以转置Mat对象。

转置的结果是原始图像的镜像版本，因此我们需要执行另一步骤以通过调用Core.flip()并将其传递到源图像和目标图像并调用翻转代码来指定如何沿垂直轴翻转图像； 0表示围绕 x 轴翻转，正值（例如1）表示围绕 y 轴翻转，负值（例如-1）表示围绕两个轴翻转。

对于 270 度旋转情况，这意味着您将手机倒置地拍照。我们遵循相同的算法，对图像进行转置然后翻转。但是，在对图像进行转置后，它将是围绕水平方向的镜像版本，因此我们将0与0翻转代码一起调用。

现在，我们准备使用图像视图组件显示图像：

private void displayImage(Mat image)
{
  // create a bitMap
  Bitmap bitMap = Bitmap.createBitmap(image.cols(), image.rows(),Bitmap.Config.RGB_565);
  // convert to bitmap:
  Utils.matToBitmap(image, bitMap);

  // find the imageview and draw it!
  ImageView iv = (ImageView) findViewById(R.id.IODarkRoomImageView);
  iv.setImageBitmap(bitMap);
}

首先，我们创建一个位图对象，其颜色通道的顺序与加载的图像颜色通道的顺序 RGB 相匹配。然后，我们使用Utils.matToBitmap()将Mat对象转换为位图对象。最后，我们使用新创建的位图对象设置图像视图位图。

计算图像直方图

我们离了解图像内容只有一步，而基本的图像分析技术之一就是计算图像直方图。

什么是直方图？

直方图是用于给定图像强度值分布的整体图。如前所述，在 x 轴上，绘图将具有0至255范围内的值，具体取决于图像深度，而 y 轴将代表相应强度值的出现次数。

一旦计算并显示图像的直方图，您就可以轻松获得有关图像对比度，强度分布等的一些见解。实际上，如果将直方图归一化，使其总和为 1，则可以将直方图视为概率密度函数，并回答诸如给定强度值出现在图像上的概率是多少的问题，答案就是 y 以该强度值读取轴。在下图中，您可以看到强度为 50 的像素出现在图像的左侧 5,000 次：

What are histograms?

了解直方图的组成部分

在我们开始学习并开始计算直方图之前，我们需要了解一些组件和术语以计算直方图：

直方图的箱子：如前所述，直方图的 x 轴表示每个像素可以存储的强度值。

例如，如果要显示强度从 0 到 255 的直方图，则将需要 256 个箱子来保存每个强度值的出现次数。但是，通常情况并非如此，因为这被认为是非常精细的直方图，并且结果可能不会提供很多信息。

要解决此问题，您可以将直方图划分为箱子，每个箱子都具有一定范围的强度。

对于我们的示例，从 0 到 255，我们可以有 25 个箱子，每个箱子将容纳 10 个连续的强度值的值，从 0 到 9，从 10 到 19，依此类推。但是，如果直方图仍然不是很具有代表性，则可以减少箱的数量，以增加每个箱中强度值的范围。
直方图尺寸：在我们的示例中，尺寸数量为 1，因为在灰度图像的情况下，对于一个通道，我们将只考虑每个像素的强度值；在灰度图像的情况下，将考虑单个色彩通道。全彩色图像。
直方图范围：这是要测量的值的极限。在我们的示例中，强度的范围是 0 到 255，因此我们要测量的值的范围将是(0, 255)，即所有强度。

现在，我们准备好来展示如何使用 OpenCV 库计算图像的直方图。

UI 定义

我们将继续在上一节中开始的同一应用上构建。所做的更改是在菜单文件中添加了另一个菜单项，以触发直方图计算。

转到res/menu/iodark_room.xml文件并打开它以包含以下菜单项：

<item
android:id="@+id/action_Hist"
android:orderInCategory="101"
android:showAsAction="never"
android:title="@string/action_Hist">
</item>

就 UI 更改而言就是这样。

计算图像直方图

在IODarkRoom 活动中，我们需要按显示直方图菜单项来处理用户。

如下编辑onOptionesItemSelected()方法：

@Override
public boolean onOptionsItemSelected(MenuItem item) {
  // Handle action bar item clicks here. The action bar will
  // automatically handle clicks on the Home/Up button, so long
  // as you specify a parent activity in AndroidManifest.xml.
  int id = item.getItemId();
  if (id == R.id.action_openGallary) {
    Intent intent = newIntent();
    intent.setType("https://gitcode.net/apachecn/apachecn-cv-zh/-/raw/master/docs/opencv-android-prog-example/img/*");
    intent.setAction(Intent.ACTION_GET_CONTENT);
    startActivityForResult(Intent.createChooser(intent,"Select Picture"), SELECT_PICTURE);
    return true;
  }
 else if (id == R.id.action_Hist) {
 if(sampledImage==null)
 {
 Context context = getApplicationContext();
 CharSequence text = "You need to load an image first!";
 int duration = Toast.LENGTH_SHORT;

 Toast toast = Toast.makeText(context, text, duration);
 toast.show();
 return true;
 }
 Mat histImage=new Mat();
 sampledImage.copyTo(histImage);
 calcHist(histImage);
 displayImage(histImage);
 return true;
  }
  return super.onOptionsItemSelected(item);
}

请注意，如果按下了显示直方图菜单项，我们首先检查用户是否已加载图像，如果用户未加载，则显示一条友好消息，然后将其返回。

现在是直方图部分，如下所示：

Mat histImage=new Mat();
sampledImage.copyTo(histImage);

calcHist(histImage);

displayImage(histImage);
return true;

我们首先制作用户加载的缩小图像的副本。这是必需的，因为我们将更改图像以显示直方图，因此我们需要获得原始副本。获得副本后，我们将调用calcHist()并将其传递给新图像：

private void calcHist(Mat image)
{
  int mHistSizeNum = 25;
  MatOfInt mHistSize = new MatOfInt(mHistSizeNum);
  Mat hist = new Mat();
  float []mBuff = new float[mHistSizeNum];
  MatOfFloat histogramRanges = new MatOfFloat(0f, 256f);
  Scalar mColorsRGB[] = new Scalar[] { new Scalar(200, 0, 0, 255), new Scalar(0, 200, 0, 255), new Scalar(0, 0, 200, 255) };
  org.opencv.core.PointmP1 = new org.opencv.core.Point();
  org.opencv.core.PointmP2 = new org.opencv.core.Point();

  int thikness = (int) (image.width() / (mHistSizeNum+10)/3);
  if(thikness> 3) thikness = 3;
  MatOfInt mChannels[] = new MatOfInt[] { new MatOfInt(0), new MatOfInt(1), new MatOfInt(2) };
  Size sizeRgba = image.size();
  int offset = (int) ((sizeRgba.width - (3*mHistSizeNum+30)*thikness));
  // RGB
  for(int c=0; c<3; c++) {
 Imgproc.calcHist(Arrays.asList(image), mChannels[c], new Mat(), hist, mHistSize, histogramRanges);
 Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
    hist.get(0, 0, mBuff);
    for(int h=0; h<mHistSizeNum; h++) {
      mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
      mP1.y = sizeRgba.height-1;
      mP2.y = mP1.y - (int)mBuff[h];
 Core.line(image, mP1, mP2, mColorsRGB[c], thikness);
    }
  }
}

calcHist()方法分为两部分。

第一部分与配置直方图的外观和定义直方图组件有关：

int mHistSizeNum = 25;
MatOfInt mHistSize = new MatOfInt(mHistSizeNum);

首先，我们定义直方图箱的个数。在这种情况下，我们的直方图将有 25 个箱子。然后，我们初始化一个MatOfInt()对象，该对象是Mat类的子类，但仅存储带有直方图箱数的整数。初始化的结果是尺寸为1 x 1 x 1 (row x col x channel)的MatOfInt对象，其中保留数字25。

注意

我们需要初始化这样的对象，因为根据规范，OpenCV 计算直方图方法采用一个Mat对象，该对象保存了直方图箱的数量。

然后，我们使用以下命令初始化一个新的Mat对象以保存直方图值：

Mat hist = newMat();

这次，Mat对象的尺寸为1 x 1 x nbins：

float []mBuff = new float[mHistSizeNum];

回想一下在本章开始的中，我们访问了图像中的各个像素。在这里，我们将使用相同的技术来访问直方图箱子的值，并将它们存储在float类型的数组中。在这里，我们定义了另一个直方图组件，即直方图范围：

MatOfFloat histogramRanges = new MatOfFloat(0f, 256f);

我们使用MatOfFloat()类；它是Mat类的子类，顾名思义，它仅包含浮点数。

初始化的结果将是尺寸为2 x 1 x 1的Mat对象，其值分别为0和256：

Scalar mColorsRGB[] = new Scalar[] { new Scalar(200, 0, 0, 255), new Scalar(0, 200, 0, 255), new Scalar(0, 0, 200, 255) };

在创建每个通道的直方图时，我们将通过绘制具有相应通道颜色的线条来区分每个通道的直方图。我们初始化一个由三个Scalar对象组成的数组，该对象只是一个长度最多为 4 的双精度数组，代表三种颜色：红色，绿色和蓝色。初始化两个点以为每个直方图箱子画一条线：

org.opencv.core.PointmP1 = new org.opencv.core.Point();
org.opencv.core.PointmP2 = new org.opencv.core.Point();

对于我们为直方图箱子绘制的每条线，我们需要指定线的粗细：

int thikness = (int) (image.width() / (mHistSizeNum+10)/3);
if(thikness> 3) thikness = 3;

使用值0，1和2初始化三个MatOfInt对象，以独立索引每个图像通道：

MatOfInt mChannels[] = new MatOfInt[] { new MatOfInt(0), new MatOfInt(1), new MatOfInt(2) };

计算开始绘制直方图的偏移量：

Size sizeRgba = image.size();
int offset = (int) ((sizeRgba.width - (3*mHistSizeNum+30)*thikness));

让我们继续进行第二部分，在其中计算和绘制直方图：

// RGB
for(int c=0; c<3; c++) {
  Imgproc.calcHist(Arrays.asList(image), mChannels[c], new Mat(), hist, mHistSize, histogramRanges);

  Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);

  hist.get(0, 0, mBuff);

  for(int h=0; h<mHistSizeNum; h++) {
    mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
    mP1.y = sizeRgba.height-1;
    mP2.y = mP1.y - (int)mBuff[h];
    Core.line(image, mP1, mP2, mColorsRGB[c], thikness);
  }
}

注意的第一件事是我们一次只能计算一个通道的直方图。这就是为什么我们为三个通道运行一个for循环的原因。至于循环的主体，第一步是调用Imgproc.calcHist()，将其传递给以下参数后执行所有繁重的工作：

Mat对象的列表。 Imgproc.calcHist()计算图像列表的直方图，在我们的示例中，我们正在传递仅包含一个图像的Mat对象列表。
通道索引的MatOfInt对象。
如果要计算图像特定区域的直方图，则将Mat对象用作遮罩。但是，在本例中，我们需要计算整个图像的直方图，这就是为什么我们发送一个空的Mat对象的原因。
一个Mat对象，用于存储直方图值。
一个MatOfInt对象，用于保存箱数。
一个MatOfFloat对象，用于保存直方图范围。

现在我们已经计算出直方图，有必要对其值进行归一化，以便可以在设备屏幕上显示它们。 Core.normalize()可以以几种不同的方式使用：

Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);

此处使用的一种方法是使用输入数组的范数进行归一化，这是本例中的直方图值，并传递以下参数：

作为要归一化的值的Mat对象。
作为归一化后的目标的Mat对象。
双 Alpha。在范数归一化的情况下，alpha 将用作范数值。对于另一种情况（范围归一化），alpha 将是范围的最小值。
双重测试版。该参数仅在范围归一化的情况下用作最大范围值。在我们的例子中，我们通过了0，因为它没有被使用。
整数范数类型。此参数指定要使用的规范化。在我们的例子中，我们传递了Core.NORM_INF，它告诉 OpenCV 使用无穷范数进行归一化，将输入数组的最大值设置为等于 alpha 参数（在本例中为图像高度的一半）。您可以使用其他规范，例如 L2 规范或 L1 规范，这分别相当于传递Core.NORM_L2或Core.NORM_L1。另外，您可以通过传递Core.MINMAX来使用范围归一化，这会将源的值归一化为 alpha 和 beta 参数之间。

标准化后，我们在float数组中检索直方图箱子值：

hist.get(0, 0, mBuff);

最后，我们使用Core.line()为直方图中的每个箱子绘制一条线：

for(int h=0; h<mHistSizeNum; h++) {
  //calculate the starting x position related to channel C plus 10 //pixels spacing multiplied by the thickness
  mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
  mP1.y = sizeRgba.height-1;
  mP2.y = mP1.y - (int)mBuff[h];
  Core.line(image, mP1, mP2, mColorsRGB[c], thikness);
}

向Core.line()传递以下参数：

要在其上绘制的Mat对象
表示行起点的Point对象
表示行终点的Point对象
表示线条颜色的Scalar对象
代表线宽的整数

最终输出将是加载的图像，其中包含每个颜色通道的直方图：

Calculating an image histogram

增强图像对比度

现在，您了解了直方图以及如何计算直方图，是时候来看一下最广泛使用的图像增强技术之一：直方图均衡化了。直方图均衡技术用于增强图像对比度，即最小和最大强度值之间的差异，以便增强可以冲洗掉的图像细节。

了解直方图均衡

从抽象的角度来看，直方图均衡化的作用是找到一个函数，该函数获取图像的原始直方图并将其转换为具有图像强度值均匀分布的拉伸直方图，从而增强图像对比度。

实际上，直方图均衡不会产生完全均衡的输出直方图。但是，它可以很好地近似所需的变换，从而可以在图像的定义的均衡范围内更均匀地分布强度值：

Understanding histogram equalization

增强灰度图像

自从本书开始以来，我们并没有真正区分将应用的算法集应用于灰度或全彩色图像。但是，将直方图均衡化应用于灰度图像与将其应用于全彩色图像具有不同的效果。

我们将首先从将直方图均衡应用于灰度图像。

UI 定义

我们将在前面开发的项目的基础上，添加更多菜单项以触发图像增强功能。

打开菜单文件res/menu/iodark_room.xml，然后添加新的子菜单：

<item android:id="@+id/enhance_gs"android:title="@string/enhance_gs"android:enabled="true"android:visible="true"android:showAsAction="always"android:titleCondensed="@string/enhance_gs_small">
  <menu>
  <item android:id="@+id/action_togs"android:title="@string/action_ctgs"/>
  <item android:id="@+id/action_egs"android:title="@string/action_eqgsistring"/>
  </menu>
</item>

在新的子菜单中，我们添加了两个新项目：一项将图像转换为灰度，第二项触发直方图均衡化。

将图像转换为灰度

OpenCV 支持多种颜色空间转换，因此将全彩色图像转换为灰度级所需的工作量非常小。

我们需要在活动中更新onOptionsItemSelected(MenuItem item)方法以处理按下新菜单项的操作，以便转换为灰度：

else if (id == R.id.action_togs) {
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  greyImage=new Mat();
 Imgproc.cvtColor(sampledImage, greyImage, Imgproc.COLOR_RGB2GRAY);
  displayImage(greyImage);
  return true;
}

我们进行检查以查看采样图像是否已加载，然后调用Imgproc.cvtColor()并将以下参数传递给它：

作为我们的源图像的Mat对象。
作为目标图像的Mat对象。
表示要从哪个色彩空间转换以及要从哪个色彩空间转换的整数。在本例中，我们选择了从 RGB 转换为灰度。

最后，我们显示灰度图像。

均衡灰度图像的直方图

我们更改了onOptionsItemSelected(MenuItem item)方法以处理直方图均衡菜单项：

else if (id == R.id.action_egs) {
  if(greyImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to convert the image to greyscale first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  Mat eqGS=new Mat();
 Imgproc.equalizeHist(greyImage, eqGS);
  displayImage(eqGS);
  return true;  
}

我们将再次检查用户是否已经将图像转换为灰度图像。否则，直方图均衡方法将失败。然后，我们调用Imgproc.equalizeHist()并传入两个参数：

作为源图像的Mat对象
作为目标图像的Mat对象

最后，我们调用displayImage()以显示增强后的图像：

Equalizing a histogram for a grayscale image

增强 HSV 图像

要使用直方图均衡来增强完整的彩色图像并获得相同的效果，即增强图像对比度，我们需要将图像从 RGB 空间转换为 HSV，然后将相同的算法应用于饱和（S）和值（V）通道。

UI 定义

所做的更改与添加新菜单项以触发 HSV 增强有关：

<item android:id="@+id/action_HSV"android:titleCondensed="@string/action_enhanceHSV"android:title="@string/action_enhanceHSV"android:enabled="true"android:showAsAction="ifRoom"android:visible="true"/>

均衡 HSV 图像的直方图

您需要掌握的主要技能是在各个基础上使用图像通道：

else if (id == R.id.action_HSV) {
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }

首先，更新onOptionsItemSelected(MenuItem item)以处理新的菜单项：

Mat V=new Mat(sampledImage.rows(),sampledImage.cols(),CvType.CV_8UC1);
Mat S=new Mat(sampledImage.rows(),sampledImage.cols(),CvType.CV_8UC1);

初始化两个新的Mat对象以保存图像值和饱和度通道：

Mat HSV=new Mat();
Imgproc.cvtColor(sampledImage, HSV, Imgproc.COLOR_RGB2HSV);

现在，我们将 RGB 图像转换为 HSV 颜色空间：

byte [] Vs=new byte[3];
byte [] vsout=new byte[1];
byte [] ssout=new byte[1];

for(int i=0;i<HSV.rows();i++){
  for(int j=0;j<HSV.cols();j++)
  {
    HSV.get(i, j,Vs);
    V.put(i,j,new byte[]{Vs[2]});
    S.put(i,j,new byte[]{Vs[1]});
  }
}

然后，我们逐像素访问图像以复制饱和度和值通道：

Imgproc.equalizeHist(V, V);
Imgproc.equalizeHist(S, S);

调用Imgproc.equalizeHist()以增强值和饱和度通道：

for(int i=0;i<HSV.rows();i++){
  for(int j=0;j<HSV.cols();j++)
  {
    V.get(i, j,vsout);
    S.get(i, j,ssout);
    HSV.get(i, j,Vs);
    Vs[2]=vsout[0];
    Vs[1]=ssout[0];
    HSV.put(i, j,Vs);
  }
}

现在，我们将增强的饱和度和值复制回原始图像：

Mat enhancedImage=new Mat();
Imgproc.cvtColor(HSV,enhancedImage,Imgproc.COLOR_HSV2RGB);
displayImage(enhancedImage);
return true;

最后，我们将 HSV 颜色空间转换为 RGB 并显示增强的图像：

Equalizing a histogram for the image saturation and value

增强 RGB 图像

在红色，绿色和蓝色通道上执行直方图均衡将给您带来不同的效果，就好像您正在调整色相一样。

UI 定义

我们将添加一个新的菜单项，以在单个通道或一组通道上执行 RGB 增强：

<item android:id="@+id/action_RGB"android:title="@string/action_RGB"android:titleCondensed="@string/action_enhanceRGB_small"android:enabled="true"android:showAsAction="ifRoom"android:visible="true">
  <menu>
    <item android:id="@+id/action_ER"android:titleCondensed="@string/action_enhance_red_small"android:title="@string/action_enhance_red"android:showAsAction="ifRoom"android:visible="true"android:enabled="true"android:orderInCategory="1"/>
    <item android:id="@+id/action_EG" android:showAsAction="ifRoom"android:visible="true"android:enabled="true"android:titleCondensed="@string/action_enhance_green_small"android:title="@string/action_enhance_green"android:orderInCategory="2"/>
    <item android:id="@+id/action_ERG" android:showAsAction="ifRoom"android:visible="true"android:enabled="true"android:titleCondensed="@string/action_enhance_red_green_small"android:title="@string/action_enhance_red_green"android:orderInCategory="3"/>
  </menu>
</item>

均衡图像颜色通道的直方图

您可能注意到逐像素访问图像的速度很慢，尤其是在图像分辨率较高的情况下。在本节中，我们将探索另一种使用图像通道的技术，该技术更快，如下所示：

else if(id==R.id.action_ER)
{
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  Mat redEnhanced=new Mat();
  sampledImage.copyTo(redEnhanced);
 Mat redMask=new Mat(sampledImage.rows(),sampledImage.cols(),sampledImage.type(),new Scalar(1,0,0,0));

此处重要的一行是初始化redMask（这是一个Mat对象），所有通道均设置为0，第一个通道除外，第一个通道是 RGB 图像中的红色通道。

然后，我们调用enhanceChannel()方法，并传入我们创建的已加载图像和通道掩码的副本：

enhanceChannel(redEnhanced,redMask);

在enhanceChannel()方法中，我们首先将加载的图像复制到另一个Mat对象：

private void enhanceChannel(Mat imageToEnhance,Mat mask)
{
  Mat channel=new  Mat(sampledImage.rows(),sampledImage.cols(),CvType.CV_8UC1);
 sampledImage.copyTo(channel,mask);

 Imgproc.cvtColor(channel, channel, Imgproc.COLOR_RGB2GRAY,1);
 Imgproc.equalizeHist(channel, channel);
 Imgproc.cvtColor(channel, channel, Imgproc.COLOR_GRAY2RGB,3);
 channel.copyTo(imageToEnhance,mask);
}

但是，这次我们将遮罩传递给复制方法，以仅提取图像的指定通道。

然后，我们将复制的通道转换为灰度颜色空间，以使深度为 8 位，并且equalizeHist()不会失败。

最后，我们将其转换为 RGB Mat对象，将增强的通道复制到红色，绿色和蓝色，然后使用相同的遮罩将增强的通道复制到传递的参数。

您可以轻松地制作自己制作的遮罩，以增强不同的通道或通道的组合。

Equalizing a histogram for the image color channels

总结

到目前为止，您应该已经了解了如何在 OpenCV 中表示和存储图像。您还开发了自己的暗室应用，从图库中加载图像，计算并显示其直方图，并在不同的颜色空间上执行直方图均衡化，以增强图像的外观。

在下一章中，我们将开发一个新的应用，以利用更多的 OpenCV 图像处理和计算机视觉算法。我们将使用算法来平滑图像并检测年龄，线条和圆圈。

三、应用 2-软件扫描程序

在本章中，我们将开始实现下一个应用，即软件扫描程序。它使人们可以为一张收据拍照，并进行一些转换以使其看起来像被扫描一样。

该应用将分为两章。在本章中，我们将介绍两个重要的主题，这些主题将帮助我们实现最终目标。

第一个主题是关于空间滤波及其定义和应用。您将学习如何减少图像噪声，也称为图像平滑。此外，您还将了解使用 OpenCV 中实现的具有高度抽象性的不同算法检测图像边缘（对象边界）的过程。

第二个主题将涉及另一种著名的形状分析技术，称为霍夫变换。您将了解该技术背后的基本思想，该思想使其变得非常流行和广泛使用，并且我们将使用 OpenCV 实现来开始将直线和圆拟合到一组边缘像素。

空间过滤

在第 2 章，“应用 1-建立自己的暗室”中，我们讨论了如何使用直方图均衡化等技术增强给定图像，以使图像更令人愉悦。增强不同色彩空间中的图像对比度。在本节中，我们将讨论另一种增强技术，通常用作许多计算机视觉算法的预处理步骤，即空间滤波。

在开始概念之前，让我们首先创建一个新的 Android 应用。我们将按照与上一章相同的步骤进行操作；但是，我们将列出与应用命名相关的不同步骤，依此类推：

创建一个新的 Android 项目并将其命名为SoftScanner。
选择包装名称；在我们的示例中，我们使用了com.app2.softscanner。
创建空白活动时，只需将其命名为SoftScanner即可。
继续执行将 OpenCV 库与新应用链接的步骤。
对于 UI 定义和权限，请遵循与上一章完全相同的步骤。
要异步加载 OpenCV 库并从设备中读取图像，请遵循第 2 章“使用 OpenCV 读取”的“App 1：建立自己的暗室”部分中完全相同的步骤。

注意

在继续之前，请确保您能够加载 OpenCV 库并读取和显示存储在手机上的图像。

了解卷积和线性过滤器

增强图像的主要目的是使图像更具吸引力并在视觉上可以接受，而您通常需要做的是强调边缘，减少噪点并有时引入模糊效果。

这些增强操作以及许多其他增强操作可以通过空间滤波来实现。我们在这里使用项目空间来强调滤波过程发生在实际的图像像素上，并将其与其他过滤器（例如频域过滤器）区分开。在前进的过程中，我们将不再讨论频域过滤器，因此从现在开始，我们将空间过滤器称为过滤器。

无论要使用哪种过滤器，通常遵循的将过滤器应用于图像的过程几乎都是标准的。简而言之，对于线性过滤器，我们考虑原始图像的每个像素（通常将其称为目标像素），并将其值替换为其周围指定邻域的加权和。之所以称为线性过滤器，是因为目标像素的新值是其附近像素的线性组合（加权和）的结果。

加权总和中的权重由过滤器核（掩码）确定；这只是我们要考虑的邻域大小的子图像。计算新目标像素值的方法是定位核，使中心权重的位置与目标像素重合。然后我们结合加权后的邻域像素（包括目标像素及其对应的权重）来获得目标像素的新值。最后，我们继续对目标图像中的每个像素重复此过程。

应用离散形式的线性过滤器的机制也称为卷积，有时将过滤器核描述为卷积核。

Understanding convolution and linear filtering

最后，我们可以总结线性卷积过程，如下所示：

定义卷积核（即，指定邻域像素的权重）。
将核放置在目标图像上，以使目标像素与核的中心重合。
将核下方的像素与核中的相应权重相乘，然后用结果替换目标像素。
对目标图像中的每个像素重复步骤 2 和 3。

消除噪音

过滤的第一个应用使图像模糊，也称为平滑。该过程的结果是具有较少噪声的目标图像。我们将介绍三种不同的模糊技术：平均，高斯和中值。

平均过滤器

通过设计卷积核，将目标像素的值替换为核下邻域的平均值，可以得到平均过滤器。

大小为3 x 3的典型卷积核k如下所示：

The averaging filter

按照前面提到的过程，每个目标像素将被其3 x 3邻域的平均值替换，更改核的大小将使使图像更加模糊，因为您在该邻域中包含了越来越多的像素。

高斯过滤器

平均过滤器平均对待邻居中的每个像素，以便邻居中的每个像素将具有相同的权重，即对新目标像素值的影响相同。

但是，在实际情况下，并非如此。通常，当我们远离目标像素的位置时，邻域的影响变得越来越弱；因此，距离目标像素越远，效果应越小，即权重越小。

使用高斯过滤器可以实现这种关系。顾名思义，此过滤器使用高斯函数通过一维公式确定给定邻域的权重分布：

The Gaussian filter

这将产生一个钟形曲线，其中a是曲线峰的高度，b是峰中心或均值的位置，c是标准差或 sigma，它指示峰宽。钟形曲线是。具有参数的钟形曲线的示例如下：a = 1, b = 0, c = 1。

The Gaussian filter

要使用高斯函数进行滤波，我们应该将其扩展到二维空间，但又不失一般性，相同的概念适用于此处绘制的一维版本。

现在，将x轴视为核中的权重索引（其中 0 是中心权重），将y轴视为权重值。因此，如果我们移动核使其中心（在x = 0处的曲线中心）与目标像素重合，则将最高权重（曲线的峰值）分配给目标像素，然后远离核中心移动，权重会继续减小，因此，对远离目标像素的像素分配的重要性较低。

中值过滤器

在该过滤器中，邻域中的像素根据其强度值进行排序，目标像素被排序后的邻域的中位数代替。中值过滤器对于消除称为椒盐噪声的一种噪声非常有效，如下所示：

The median filter

UI 定义

对于每种过滤器类型，我们将在应用中添加不同的菜单项。转到res/menu/soft_scanner.xml文件并打开它以包含以下菜单项：

<item
  android:id="@+id/img_blurr"
  android:enabled="true"
  android:orderInCategory="4"
  android:showAsAction="ifRoom"
  android:title="@string/list_blurr"
  android:titleCondensed="@string/list_blurr_small"
  android:visible="true">
  <menu>
    <item
      android:id="@+id/action_average"
      android:title="@string/action_average"/>
    <item
      android:id="@+id/action_gaussian"
      android:title="@string/action_gaussian"/>
    <item
      android:id="@+id/action_median"
      android:title="@string/action_median"/>
   </menu>
</item>

应用过滤器以减少图像噪点

OpenCV 为我们在此讨论的每个过滤器提供了一种的即用型实现。我们需要做的就是指定一些特定于过滤器的参数，然后我们就可以开始了。

在SoftScanner活动中，我们需要编辑onOptionesItemSelected()方法并添加以下情况：

else if(id==R.id.action_average)
{
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  Mat blurredImage=new Mat();
  Size size=new Size(7,7);
 Imgproc.blur(sampledImage, blurredImage, size);

  displayImage(blurredImage);
  return true;  
}
else if(id==R.id.action_gaussian)
{
  /* code to handle the user not loading an image**/

  /**/
  Mat blurredImage=new Mat();
  Size size=new Size(7,7);
 Imgproc.GaussianBlur(sampledImage, blurredImage, size, 0,0);

  displayImage(blurredImage);
  return true;
}
else if(id==R.id.action_median)
{
  /* code to handle the user not loading an image**/

  /**/
  Mat blurredImage=new Mat();
  int kernelDim=7;
 Imgproc.medianBlur(sampledImage,blurredImage , kernelDim);

  displayImage(blurredImage);
  return true;
}

对于每个选定的过滤器，我们遵循相同的过程：

如果用户未从图库中选择或加载图片，我们将处理以下情况：

if(sampledImage==null)
{
  Context context = getApplicationContext();
  CharSequence text = "You need to load an image first!";
  int duration = Toast.LENGTH_SHORT;

  Toast toast = Toast.makeText(context, text, duration);
  toast.show();
  return true;
}

对于平均过滤器，我们调用Imgproc.blur()方法，并传入以下参数：
- 输入图像的Mat对象；它可以具有任意数量的通道，这些通道是独立处理的。
- 应用过滤器后，输出图像的Mat对象。
- 指示要使用的核（邻居）大小的Size对象。在我们的例子中，核的大小为7 x 7。
```
Mat blurredImage=new Mat();
Size size=new Size(7,7);
Imgproc.blur(sampledImage, blurredImage, size);
displayImage(blurredImage);
return true;
```
要应用高斯过滤器，我们使用以下参数调用Imgproc.GaussianBlur()方法：
- 输入图像的Mat对象。
- 输出图像的Mat对象。
- 指示核大小的Size对象。您可以使用不同高度和宽度的核。但是，两者都应为奇数和正数。
- 代表x方向上标准差的双精度型。在我们的例子中，我们将其设置为0，以便 OpenCV 根据核宽度为我们计算该值。
- 代表y方向标准差的双精度型，我们也将其设置为0，以便 OpenCV 根据核高度计算值：
```
Mat blurredImage=new Mat();
Size size=new Size(7,7);
Imgproc.GaussianBlur(sampledImage, blurredImage, size, 0,0);
displayImage(blurredImage);
return true;
```
最后，要使用中值过滤器，我们使用以下参数调用Imgproc.medianBlur()：
- 输入图像的Mat对象。
- 输出图像的Mat对象。
- 一个代表核大小的整数，我们使用一个值，因为中值过滤器是盒式过滤器（即核宽度等于其高度）。但是，核维的值应为正数和奇数。
```
Mat blurredImage=new Mat();
int kernelDim=7;
Imgproc.medianBlur(sampledImage,blurredImage , kernelDim);
displayImage(blurredImage);
return true;
```

下图显示了三个使用不同核大小的平均过滤器的示例（左：11，中心：25和右：35）。您会看到，随着核大小的增加，详细信息开始被淘汰：

Applying filters to reduce image noise

下图是示例，该示例显示了中值过滤器在消除椒盐噪声中的效果：

Applying filters to reduce image noise

寻找边缘

空间滤波的另一个应用是在图像中找到边缘（对象边界）。边缘检测的过程取决于计算像素强度变化的速率。凭直觉，当变化率高时，在该区域中更有可能存在边缘。

为了计算变化率，我们使用离散域中的导数的概念，因为对于大小为n x n的图像，我们只有行号1, 2, ..., n和列号1, 2, ..., n，而我们没有行号1.1, 1.2, ...。

让我们考虑图像I(x, y)，其中x是列号，y是行号。由于它是两个变量的函数，因此我们将根据x的离散导数逼近公式，使用独立地为每个变量计算偏导数：

Finding edges

这是图像相对于x的一阶导数，并且为了计算图像相对于y的一阶导数，我们使用以下公式：

Finding edges

因此，对于x取图像的导数非常简单。我们取x + 1的像素值，并从x-1的像素中减去它，这称为中心差，y也是如此。

最后，由于图像具有二维（行和列），因此对于每个像素（一个用于x方向，一个用于y方向），我们得到一个梯度向量[∂I/∂x; ∂I/∂y]，并且由于它是向量，所以它可以告诉我们两件事：

代表该像素边缘强度的梯度量级
代表边缘方向的梯度方向

展望未来，我们可以设计一个简单的核来计算平均中心差，以找到图像在x和y方向上的导数，如下所示：

Finding edges

现在，我们可以按照以下步骤总结一阶导数边缘检测过程：

我们使用平滑过滤器对图像进行平滑处理（以消除噪点）。
计算x方向的导数；输出将是被核过滤为K[x]的图像。
计算y方向的导数；输出将是另一个以K[y]核过滤的图像。
计算每个像素的梯度大小。
阈值梯度量，即，如果像素的梯度量大于某个阈值，则为边缘。否则，事实并非如此。

下图是一个示例，它针对原始图像（左）在x方向上计算一阶导数以检测垂直边缘（中心），对于y方向来计算水平边缘（右）：

Finding edges

Sobel 边缘检测器

OpenCV 为提供了不同的边缘检测器。我们将开始使用的设备命名为 Sobel 边缘检测器。这里的主要思想是卷积核的设计：

The Sobel edge detector

核更加强调K[x]的中心行和K[y]的中心列。

Canny 边缘检测器

另一个非常好的边缘检测器（也称为最佳检测器）是 Canny 边缘检测器。

在 Canny 边缘检测器中，我们通过以下步骤确定边缘像素：

我们使用高斯过滤器平滑处理图像。
使用例如 Sobel 过滤器为每个像素计算梯度向量。
通过将每个像素的梯度大小与其在梯度方向上的邻域进行比较，来抑制非最大像素。我们确定它是边缘的一部分，因此，如果其梯度幅度最大，则将其保留。
最后，Canny 对称为滞后的过程使用两个阈值（低和高）来确定保留的像素：
- 如果像素的梯度幅度大于高阈值，则该像素被接受为边缘像素。
- 如果像素的梯度幅度小于低阈值，则立即拒绝像素。
- 如果像素梯度幅度在高阈值和低阈值之间，并且它连接到梯度幅度高于高阈值的像素，则该像素将被视为边缘像素。

UI 定义

我们将在我们的应用中添加一些菜单项，以触发我们将使用的不同边缘检测器。转到res/menu/soft_scanner.xml文件并打开它以包含以下菜单项：

<item
  android:id="@+id/img_edge_detection"
  android:enabled="true"
  android:orderInCategory="5"
  android:showAsAction="ifRoom"
  android:title="@string/list_ed"
  android:titleCondensed="@string/list_ed_small"
  android:visible="true">
  <menu>
    <item
      android:id="@+id/action_sobel"
      android:title="@string/action_sobel"/>
    <item
      android:id="@+id/action_canny"
      android:title="@string/action_canny"/>
  </menu>
</item>

应用 Sobel 过滤器查找边缘

在本节中，我们将同时使用 Sobel 和 Canny 边缘检测器来查找图像中的边缘。我们将从 Sobel 边缘过滤器开始。

在SoftScanner活动中，我们需要编辑onOptionesItemSelected()方法并添加以下情况：

else if(id==R.id.action_sobel)
{
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  Mat blurredImage=new Mat();
  Size size=new Size(7,7);
 Imgproc.GaussianBlur(sampledImage, blurredImage, size, 0,0);

  Mat gray = new Mat();
 Imgproc.cvtColor(blurredImage, gray, Imgproc.COLOR_RGB2GRAY);

  Mat xFirstDervative =new Mat(),yFirstDervative =new Mat();
  int ddepth=CvType.CV_16S;

 Imgproc.Sobel(gray, xFirstDervative,ddepth , 1,0);
 Imgproc.Sobel(gray, yFirstDervative,ddepth , 0,1);

  Mat absXD=new Mat(),absYD=new Mat();

 Core.convertScaleAbs(xFirstDervative, absXD);
 Core.convertScaleAbs(yFirstDervative, absYD);

  Mat edgeImage=new Mat();
 Core.addWeighted(absXD, 0.5, absYD, 0.5, 0, edgeImage);

  displayImage(edgeImage);
  return true;
}

由于 Sobel 是一阶导数边缘检测器，因此我们将遵循前面概述的过程：

我们使用您之前了解的模糊过滤器之一来平滑图像，以减少我们计算边缘像素时的噪声响应。就我们而言，在大多数情况下，我们使用大小为7 x 7的高斯过滤器：
```
Mat blurredImage=new Mat();
Size size=new Size(7,7);
Imgproc.GaussianBlur(sampledImage, blurredImage, size, 0,0);
```

将平滑图像转换为灰度图像：

Mat gray = new Mat();
Imgproc.cvtColor(blurredImage, gray, Imgproc.COLOR_RGB2GRAY);

使用Imgproc.Sobel()并传入以下参数，计算灰度图像的x和y一阶导数：
- 作为源图像的Mat对象。
- 作为输出图像的Mat对象。
- 一个整数深度，用于指示输出图像的深度。在大多数情况下，输入和输出图像的深度相同。但是，当我们在某些情况下计算导数时，该值为负（即，从白色（255）变为黑色（0，derivative = -255 - 0 = -255）。因此，如果我们使用的Mat对象的深度为无符号 8 位（灰色图像仅保留 0 到 255 之间的值），则负导数的值将溢出并设置为0，即错过这个边。要变通解决此问题，我们使用带符号的 16 位深度输出图像来存储负导数。
- 我们要计算的x阶的整数。我们将其设置为1以计算x的一阶导数。
- 我们要计算的y阶的整数。我们将其设置为1以计算y的一阶导数。
  
  注意
  
  注意，要计算x方向上的梯度，我们使用x-order = 1和y-order = 0。我们对y方向类似地做。
  
  以下是代码：
```
Mat xFirstDervative =new Mat(),yFirstDervative =new Mat();
int ddepth=CvType.CV_16S;

Imgproc.Sobel(gray, xFirstDervative,ddepth , 1,0);
Imgproc.Sobel(gray, yFirstDervative,ddepth , 0,1);
```
我们调用Core.convertScaleAbs()在输入Mat对象上依次执行三个操作：
- 缩放输入Mat对象的值；但是，由于我们没有传递任何缩放因子，因此跳过了缩放步骤。
- 取输入Mat对象中每个元素的绝对值。我们需要此步骤，因为我们存储了x和y一阶导数的负值，但实际上我们关心导数的绝对值，并且我们希望能够将这些值存储在无符号的 8 位Mat对象中（存储从 0 到 255 的值）。
- 转换为无符号的 8 位深度Mat对象。
Core.convertScaleAbs()的参数是输入和输出Mat对象：
```
Mat absXD=new Mat(),absYD=new Mat();
Core.convertScaleAbs(xFirstDervative, absXD);
Core.convertScaleAbs(yFirstDervative, absYD);
```
我们尝试使用Core.addWeighted()来估计梯度大小以显示边缘图像，该函数计算两个图像的加权和。我们通过传递以下参数来实现：
- 第一张图片的Mat对象。我们在x方向传递了绝对一阶导数。
- 第一张图片的权重的两倍；在我们的例子中，两个图像均为0.5。
- 第二个图像的Mat对象。我们沿y方向传递了绝对一阶导数。
- 第二张图像的权重的两倍。
- 每个总和加一个双精度值。我们不需要添加任何内容，因此我们发送0。
- 一个Mat对象，用于存储输出图像。
注意

这是梯度量的近似值。就本示例而言，这是好的。但是，如果需要计算实际的梯度幅度，则必须使用此公式gradient magnitude = √(f[x]² + f[y]²)，其中f[x], f[y]分别是x和y方向上的一阶导数的值。

以下是代码：
```
Mat edgeImage=new Mat();
Core.addWeighted(absXD, 0.5, absYD, 0.5, 0, edgeImage);
```
最后，我们显示edgeImage：
```
displayImage(edgeImage);
```
应用 Sobel 过滤器检测边缘的示例

使用 Canny 边缘检测器

应用 Canny 边缘检测器更为简单；我们实际上只需要在 OpenCV 中执行一个功能，Canny 边缘检测器的所有步骤都将为我们执行。通过这种抽象水平，我们只需要指定一些算法参数即可。

在SoftScanner活动中，我们需要编辑onOptionesItemSelected()方法并添加以下情况：

else if(id==R.id.action_canny)
{
  if(sampledImage==null)
  {
    Context context = getApplicationContext();
    CharSequence text = "You need to load an image first!";
    int duration = Toast.LENGTH_SHORT;

    Toast toast = Toast.makeText(context, text, duration);
    toast.show();
    return true;
  }
  Mat gray = new Mat();
 Imgproc.cvtColor(sampledImage, gray, Imgproc.COLOR_RGB2GRAY);

  Mat edgeImage=new Mat();
 Imgproc.Canny(gray, edgeImage, 100, 200);

  displayImage(edgeImage);
  return true;  
}

您可以看到这些步骤更加简单：

我们将输入图像转换为灰度，因为 Canny 仅适用于灰度图像：

Mat gray = new Mat();
Imgproc.cvtColor(sampledImage, gray, Imgproc.COLOR_RGB2GRAY);

我们调用Imgproc.Canny()并传递以下参数：
- 作为输入灰度图像的Mat对象
- 输出边缘图像的Mat对象
- 迟滞步骤中下限阈值的两倍
- 迟滞步骤中上限的两倍
注意

Canny 建议将上限阈值和下限阈值的比率设置为 2:1 到 3:1。

以下是代码：
```
Mat edgeImage=new Mat();
Imgproc.Canny(gray, edgeImage, 100, 200);
```
最后，我们显示edgeImage：
```
displayImage(edgeImage);
```
应用 Canny 边缘检测器的示例

检测形状

因此，我们已经看到如何检测边缘；但是，此过程是逐个像素的过程，回答了该像素是否为边缘的问题。展望未来，在形状分析中，我们不仅需要边缘测试，还需要更多具体的信息。我们将需要更好的代表。

例如，如果我们有一个盒子的图片，并且进行了边缘检测，那么最终将得到成千上万的边缘像素。但是，如果我们尝试使一条线适合这些边缘像素，则会得到一个矩形，这是一种更具符号性和实用性的表示形式。

了解霍夫线变换

有许多方法可以使一条线穿过多个点，并且霍夫变换被认为是一种约束不足的方法，其中我们仅使用一个点来查找所有可以通过该点的线，我们使用另一个点来查找所有可以通过它的线，并且我们继续对所有点进行此操作。

我们最终得到一个投票系统，其中每个点都为一条线投票，并且同一条线上的点越多，对该行的投票就越高。简而言之，霍夫变换可以描述为将x, y空间中的点映射到感兴趣形状的参数空间。

利用x和y空间中的直线方程y = ax + b，将其变换为斜率(a)的空间并截取空间（b），并给出此变换，得出x和y空间中的点，实际上是斜率与截距空间中的一条线，其方程式为b = -ax + y：