From 015f9d54e28887d73b2e6f880ef85023f0b80683 Mon Sep 17 00:00:00 2001 From: shubham0204 Date: Thu, 30 Sep 2021 07:29:43 +0530 Subject: [PATCH 1/6] Added depth estimation project --- README.md | 9 + depth_estimation/LICENSE.txt | 201 +++++++++++++++++ depth_estimation/README.md | 73 ++++++ depth_estimation/app/.gitignore | 1 + depth_estimation/app/build.gradle | 60 +++++ depth_estimation/app/proguard-rules.pro | 21 ++ .../app/src/main/AndroidManifest.xml | 26 +++ .../ml/depthestimation/BitmapUtils.kt | 97 ++++++++ .../ml/depthestimation/DrawingOverlay.kt | 59 +++++ .../ml/depthestimation/FrameAnalyser.kt | 78 +++++++ .../shubham0204/ml/depthestimation/Logger.kt | 36 +++ .../ml/depthestimation/MainActivity.kt | 208 ++++++++++++++++++ .../ml/depthestimation/MiDASModel.kt | 151 +++++++++++++ .../drawable-v24/ic_launcher_foreground.xml | 30 +++ .../res/drawable/depth_map_toggle_icon.xml | 5 + .../main/res/drawable/flip_camera_icon.xml | 5 + .../res/drawable/ic_launcher_background.xml | 170 ++++++++++++++ .../app/src/main/res/layout/activity_main.xml | 53 +++++ .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 + .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 + .../src/main/res/mipmap-hdpi/ic_launcher.webp | Bin 0 -> 1404 bytes .../res/mipmap-hdpi/ic_launcher_round.webp | Bin 0 -> 2898 bytes .../src/main/res/mipmap-mdpi/ic_launcher.webp | Bin 0 -> 982 bytes .../res/mipmap-mdpi/ic_launcher_round.webp | Bin 0 -> 1772 bytes .../main/res/mipmap-xhdpi/ic_launcher.webp | Bin 0 -> 1900 bytes .../res/mipmap-xhdpi/ic_launcher_round.webp | Bin 0 -> 3918 bytes .../main/res/mipmap-xxhdpi/ic_launcher.webp | Bin 0 -> 2884 bytes .../res/mipmap-xxhdpi/ic_launcher_round.webp | Bin 0 -> 5914 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.webp | Bin 0 -> 3844 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.webp | Bin 0 -> 7778 bytes .../app/src/main/res/values-night/themes.xml | 16 ++ .../app/src/main/res/values/colors.xml | 10 + .../app/src/main/res/values/strings.xml | 3 + .../app/src/main/res/values/themes.xml | 16 ++ depth_estimation/build.gradle | 18 ++ depth_estimation/gradle.properties | 21 ++ .../gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 59203 bytes .../gradle/wrapper/gradle-wrapper.properties | 6 + depth_estimation/gradlew | 185 ++++++++++++++++ depth_estimation/gradlew.bat | 89 ++++++++ depth_estimation/repo_images/depth_sample.jpg | Bin 0 -> 21138 bytes depth_estimation/repo_images/rgb_sample.jpg | Bin 0 -> 50387 bytes depth_estimation/settings.gradle | 10 + 43 files changed, 1667 insertions(+) create mode 100644 depth_estimation/LICENSE.txt create mode 100644 depth_estimation/README.md create mode 100644 depth_estimation/app/.gitignore create mode 100644 depth_estimation/app/build.gradle create mode 100644 depth_estimation/app/proguard-rules.pro create mode 100644 depth_estimation/app/src/main/AndroidManifest.xml create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/BitmapUtils.kt create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/DrawingOverlay.kt create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/FrameAnalyser.kt create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/Logger.kt create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MainActivity.kt create mode 100644 depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt create mode 100644 depth_estimation/app/src/main/res/drawable-v24/ic_launcher_foreground.xml create mode 100644 depth_estimation/app/src/main/res/drawable/depth_map_toggle_icon.xml create mode 100644 depth_estimation/app/src/main/res/drawable/flip_camera_icon.xml create mode 100644 depth_estimation/app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 depth_estimation/app/src/main/res/layout/activity_main.xml create mode 100644 depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-mdpi/ic_launcher.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp create mode 100644 depth_estimation/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp create mode 100644 depth_estimation/app/src/main/res/values-night/themes.xml create mode 100644 depth_estimation/app/src/main/res/values/colors.xml create mode 100644 depth_estimation/app/src/main/res/values/strings.xml create mode 100644 depth_estimation/app/src/main/res/values/themes.xml create mode 100644 depth_estimation/build.gradle create mode 100644 depth_estimation/gradle.properties create mode 100644 depth_estimation/gradle/wrapper/gradle-wrapper.jar create mode 100644 depth_estimation/gradle/wrapper/gradle-wrapper.properties create mode 100644 depth_estimation/gradlew create mode 100644 depth_estimation/gradlew.bat create mode 100644 depth_estimation/repo_images/depth_sample.jpg create mode 100644 depth_estimation/repo_images/rgb_sample.jpg create mode 100644 depth_estimation/settings.gradle diff --git a/README.md b/README.md index 50d6bf9..6a15075 100644 --- a/README.md +++ b/README.md @@ -46,6 +46,15 @@ Artistic style transfer is an optimization technique used to take two images: a Added from: https://github.com/tensorflow/examples/tree/master/lite/examples +### Depth Estimation + +Perform realtime depth estimation using the MiDaS model available on [TensorFlow Hub](https://tfhub.dev/intel/midas/v2_1_small/1). This project is added from [shubham0204 +/ +Realtime_MiDaS_Depth_Estimation_Android](https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android). Refer to the [README](https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android/blob/master/README.md) for all the details. + +Added from: https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android + + ### Coming Soon! πŸš€ **BERT qa** diff --git a/depth_estimation/LICENSE.txt b/depth_estimation/LICENSE.txt new file mode 100644 index 0000000..29f81d8 --- /dev/null +++ b/depth_estimation/LICENSE.txt @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/depth_estimation/README.md b/depth_estimation/README.md new file mode 100644 index 0000000..8f9e655 --- /dev/null +++ b/depth_estimation/README.md @@ -0,0 +1,73 @@ +
+

Realtime Depth Estimation In Android With MiDaS

+
+ +![depth image sample](repo_images/depth_sample.jpg) +![camera sample](repo_images/rgb_sample.jpg) + +* [Official MiDaS GitHub repo](https://github.com/isl-org/MiDaS) +* [TFLite model on TensorFlow Hub](https://tfhub.dev/intel/midas/v2_1_small/1) +* [APK for this project](https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android/raw/master/app.apk) + +The repository contains an Android project which uses the [MiDaS](https://github.com/isl-org/MiDaS) model to perform monocular +depth estimation. You can find the official Android example here -> https://github.com/isl-org/MiDaS/tree/master/mobile/android + +This project uses the TFLite model from the [MiDaS's TensorFlow Hub repo](https://tfhub.dev/intel/midas/v2_1_small/1). +The following features are included in the project, + +1. Well documented code with links to SO answers wherever required. +2. Uses latest APIs like [CameraX](https://developer.android.com/training/camerax) and [Kotlin Coroutines](https://developer.android.com/kotlin/coroutines). +3. No use of heavy packages like OpenCV to process and display the depth map. The application is coded in a +*Android* friendly manner. +4. Works for both front and rear camera and also in portrait and landscape orientations. + +### Project info: + +``` +compileSdk 30 +applicationId "com.shubham0204.ml.depthestimation" +minSdk 23 +targetSdk 30 +androidGradlePluginVersion 7.0.0 +gradlePluginVersion 7.0.2 +``` + + +## Citation + +``` +@article{DBLP:journals/corr/abs-1907-01341, + author = {Katrin Lasinger and + Ren{\'{e}} Ranftl and + Konrad Schindler and + Vladlen Koltun}, + title = {Towards Robust Monocular Depth Estimation: Mixing Datasets for Zero-Shot + Cross-Dataset Transfer}, + journal = {CoRR}, + volume = {abs/1907.01341}, + year = {2019}, + url = {http://arxiv.org/abs/1907.01341}, + archivePrefix = {arXiv}, + eprint = {1907.01341}, + timestamp = {Mon, 08 Jul 2019 14:12:33 +0200}, + biburl = {https://dblp.org/rec/journals/corr/abs-1907-01341.bib}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} +``` + +## License + +``` +Copyright 2021 Shubham Panchal +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. +``` diff --git a/depth_estimation/app/.gitignore b/depth_estimation/app/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/depth_estimation/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/depth_estimation/app/build.gradle b/depth_estimation/app/build.gradle new file mode 100644 index 0000000..143c7c3 --- /dev/null +++ b/depth_estimation/app/build.gradle @@ -0,0 +1,60 @@ +plugins { + id 'com.android.application' + id 'kotlin-android' +} + +android { + compileSdk 30 + + defaultConfig { + applicationId "com.shubham0204.ml.depthestimation" + minSdk 23 + targetSdk 30 + versionCode 1 + versionName "1.0" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + aaptOptions { + noCompress "tflite" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + kotlinOptions { + jvmTarget = '1.8' + } +} + +dependencies { + implementation 'androidx.core:core-ktx:1.6.0' + implementation 'androidx.appcompat:appcompat:1.3.1' + implementation 'com.google.android.material:material:1.4.0' + implementation 'androidx.constraintlayout:constraintlayout:2.1.0' + + // CameraX dependencies + implementation "androidx.camera:camera-camera2:1.0.0" + implementation "androidx.camera:camera-lifecycle:1.0.0" + implementation "androidx.camera:camera-view:1.0.0-alpha26" + implementation "androidx.camera:camera-extensions:1.0.0-alpha26" + + // TensorFlow Lite dependencies + implementation 'org.tensorflow:tensorflow-lite:2.4.0' + implementation 'org.tensorflow:tensorflow-lite-gpu:2.4.0' + implementation 'org.tensorflow:tensorflow-lite-support:0.1.0' + + // Kotlin Coroutines + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9' + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9' + + testImplementation 'junit:junit:4.+' + androidTestImplementation 'androidx.test.ext:junit:1.1.3' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' +} \ No newline at end of file diff --git a/depth_estimation/app/proguard-rules.pro b/depth_estimation/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/depth_estimation/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/depth_estimation/app/src/main/AndroidManifest.xml b/depth_estimation/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..633dd88 --- /dev/null +++ b/depth_estimation/app/src/main/AndroidManifest.xml @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/BitmapUtils.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/BitmapUtils.kt new file mode 100644 index 0000000..85512fe --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/BitmapUtils.kt @@ -0,0 +1,97 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.content.Context +import android.graphics.* +import android.media.Image +import java.io.ByteArrayOutputStream +import java.io.File +import java.io.FileOutputStream + +// Helper class for operations on Bitmaps +class BitmapUtils { + + companion object { + + // Rotate the given `source` by `degrees`. + // See this SO answer -> https://stackoverflow.com/a/16219591/10878733 + fun rotateBitmap( source: Bitmap , degrees : Float ): Bitmap { + val matrix = Matrix() + matrix.postRotate( degrees ) + return Bitmap.createBitmap(source, 0, 0, source.width, source.height, matrix , false ) + } + + + // Use this method to save a Bitmap to the internal storage ( app-specific storage ) of your device. + // To see the image, go to "Device File Explorer" -> "data" -> "data" -> "com.ml.quaterion.facenetdetection" -> "files" + fun saveBitmap(context: Context, image: Bitmap, name: String) { + val fileOutputStream = FileOutputStream(File( context.filesDir.absolutePath + "/$name.png")) + image.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream) + } + + + // Resize the given Bitmap with given `targetWidth` and `targetHeight`. + // See this SO answer -> https://stackoverflow.com/a/65574102/10878733 + fun resizeBitmap( src : Bitmap , targetWidth : Int , targetHeight : Int ) : Bitmap { + return Bitmap.createScaledBitmap( src , targetWidth , targetHeight , true ) + } + + + // Flip the given `Bitmap` vertically. + // See this SO answer -> https://stackoverflow.com/a/36494192/10878733 + fun flipBitmap( source: Bitmap ): Bitmap { + val matrix = Matrix() + matrix.postScale(-1f, 1f, source.width / 2f, source.height / 2f) + return Bitmap.createBitmap(source, 0, 0, source.width, source.height, matrix, true) + } + + + fun byteBufferToBitmap( imageArray : FloatArray , imageDim : Int ) : Bitmap { + val pixels = imageArray.map { it.toInt() }.toIntArray() + val bitmap = Bitmap.createBitmap(imageDim, imageDim, Bitmap.Config.RGB_565 ); + for ( i in 0 until imageDim ) { + for ( j in 0 until imageDim ) { + val p = pixels[ i * imageDim + j ] + bitmap.setPixel( j , i , Color.rgb( p , p , p )) + } + } + return bitmap + } + + + // Convert android.media.Image to android.graphics.Bitmap and rotate it by `rotationDegrees` + // See the SO answer -> https://stackoverflow.com/a/44486294/10878733 + fun imageToBitmap( image : Image , rotationDegrees : Int ): Bitmap { + val yBuffer = image.planes[0].buffer + val uBuffer = image.planes[1].buffer + val vBuffer = image.planes[2].buffer + val ySize = yBuffer.remaining() + val uSize = uBuffer.remaining() + val vSize = vBuffer.remaining() + val nv21 = ByteArray(ySize + uSize + vSize) + yBuffer.get(nv21, 0, ySize) + vBuffer.get(nv21, ySize, vSize) + uBuffer.get(nv21, ySize + vSize, uSize) + val yuvImage = YuvImage(nv21, ImageFormat.NV21, image.width, image.height, null) + val out = ByteArrayOutputStream() + yuvImage.compressToJpeg(Rect(0, 0, yuvImage.width, yuvImage.height), 100, out) + val yuv = out.toByteArray() + return rotateBitmap( BitmapFactory.decodeByteArray(yuv, 0, yuv.size) , rotationDegrees.toFloat() ) + } + + } + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/DrawingOverlay.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/DrawingOverlay.kt new file mode 100644 index 0000000..0c601bb --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/DrawingOverlay.kt @@ -0,0 +1,59 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.Canvas +import android.util.AttributeSet +import android.view.SurfaceHolder +import android.view.SurfaceView + +// Overlay to display the depth map over the `PreviewView`. +// See activity_main.xml +class DrawingOverlay(context : Context, attributeSet : AttributeSet) : SurfaceView( context , attributeSet ) , SurfaceHolder.Callback { + + // This variable is assigned in FrameAnalyser.kt + var depthMaskBitmap : Bitmap? = null + + // These variables are assigned in MainActivity.kt + var isFrontCameraOn = true + var isShowingDepthMap = false + + + + override fun surfaceCreated(holder: SurfaceHolder) { + } + + + override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) { + } + + + override fun surfaceDestroyed(holder: SurfaceHolder) { + } + + + // Will be called when `drawingOverlay.invalidate()` is called in FrameAnalyser.kt. + override fun onDraw(canvas: Canvas?) { + if ( depthMaskBitmap != null && isShowingDepthMap ) { + // If the front camera is on, then flip the Bitmap vertically ( or produce a mirror image of it ). + canvas?.drawBitmap( + if ( isFrontCameraOn ) { BitmapUtils.flipBitmap( depthMaskBitmap!! ) } else { depthMaskBitmap!! }, + 0f , 0f , null ) + } + } + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/FrameAnalyser.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/FrameAnalyser.kt new file mode 100644 index 0000000..c4a3ed4 --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/FrameAnalyser.kt @@ -0,0 +1,78 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.graphics.Bitmap +import android.view.View +import androidx.camera.core.ImageAnalysis +import androidx.camera.core.ImageProxy +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +// Image Analyser for performing depth estimation on camera frames. +class FrameAnalyser( + private var depthEstimationModel : MiDASModel , + private var drawingOverlay: DrawingOverlay ) : ImageAnalysis.Analyzer { + + private var frameBitmap : Bitmap? = null + private var isFrameProcessing = false + var isComputingDepthMap = false + + + + override fun analyze(image: ImageProxy) { + // Return if depth map computation is turned off. See MainActivity.kt + if ( !isComputingDepthMap ) { + image.close() + return + } + // If a frame is being processed, drop the current frame. + if ( isFrameProcessing ) { + image.close() + return + } + isFrameProcessing = true + if ( image.image != null ) { + // Get the `Bitmap` of the current frame ( with corrected rotation ). + frameBitmap = BitmapUtils.imageToBitmap( image.image!! , image.imageInfo.rotationDegrees ) + image.close() + CoroutineScope( Dispatchers.Main ).launch { + runModel( frameBitmap!! ) + } + } + } + + + private suspend fun runModel( inputImage : Bitmap ) = withContext( Dispatchers.Default ) { + // Compute the depth given the frame Bitmap. + val output = depthEstimationModel.getDepthMap( inputImage ) + withContext( Dispatchers.Main ) { + // Notify that the current frame is processed and the pipeline is + // ready for the next frame. + isFrameProcessing = false + if ( drawingOverlay.visibility == View.GONE ) { + drawingOverlay.visibility = View.VISIBLE + } + // Submit the depth Bitmap to the DrawingOverlay and update it. + // Note, calling `drawingOverlay.invalidate()` here will call `onDraw()` in DrawingOverlay.kt. + drawingOverlay.depthMaskBitmap = BitmapUtils.resizeBitmap( output , + frameBitmap!!.width , frameBitmap!!.height) + drawingOverlay.invalidate() + } + } + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/Logger.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/Logger.kt new file mode 100644 index 0000000..9dc15ae --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/Logger.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.util.Log + +// Utility class to log messages +class Logger { + + companion object { + + private val APP_LOG_TAG = "Depth_Estimation_App" + + fun logError( message : String ) { + Log.e( APP_LOG_TAG , message ) + } + + fun logInfo( message : String ) { + Log.i( APP_LOG_TAG , message ) + } + + } + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MainActivity.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MainActivity.kt new file mode 100644 index 0000000..1197aca --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MainActivity.kt @@ -0,0 +1,208 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.Manifest +import android.content.pm.PackageManager +import android.content.res.ColorStateList +import android.graphics.Color +import android.os.Bundle +import android.util.Size +import android.view.View +import android.widget.Toast +import androidx.activity.result.contract.ActivityResultContracts +import androidx.appcompat.app.AlertDialog +import androidx.appcompat.app.AppCompatActivity +import androidx.camera.core.CameraSelector +import androidx.camera.core.ImageAnalysis +import androidx.camera.core.Preview +import androidx.camera.lifecycle.ProcessCameraProvider +import androidx.camera.view.PreviewView +import androidx.core.app.ActivityCompat +import androidx.core.content.ContextCompat +import androidx.lifecycle.LifecycleOwner +import com.google.android.material.floatingactionbutton.FloatingActionButton +import com.google.common.util.concurrent.ListenableFuture +import java.util.concurrent.ExecutionException +import java.util.concurrent.Executors + +class MainActivity : AppCompatActivity() { + + private lateinit var previewView : PreviewView + private lateinit var drawingOverlay: DrawingOverlay + + private var preview: Preview? = null + private lateinit var cameraProviderListenableFuture : ListenableFuture + private lateinit var frameAnalyser : FrameAnalyser + private var frameAnalysis: ImageAnalysis? = null + + private var isFrontCameraOn = true + private var isDepthMapDisplayed = false + + + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + // Remove the status bar to have a full screen experience + // See this answer on SO -> https://stackoverflow.com/a/68152688/10878733 + window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN + setContentView(R.layout.activity_main) + + previewView = findViewById( R.id.camera_preview_view ) + + // Make sure that the DrawingOverlay remains on top + // See this SO answer -> https://stackoverflow.com/a/28883273/10878733 + drawingOverlay = findViewById( R.id.camera_drawing_overlay ) + drawingOverlay.setWillNotDraw(false) + drawingOverlay.setZOrderOnTop(true) + + val depthEstimationModel = MiDASModel( this ) + frameAnalyser = FrameAnalyser( depthEstimationModel , drawingOverlay ) + + val flipCameraFAB = findViewById( R.id.flip_camera_fab ) + flipCameraFAB.setOnClickListener { + when( isFrontCameraOn ) { + true -> setupCameraProvider( CameraSelector.LENS_FACING_BACK ) + false -> setupCameraProvider( CameraSelector.LENS_FACING_FRONT ) + } + // Alert the DrawingOverlay regarding the change in lens facing. + // This is important as for the front camera, we need to flip ( vertically ) the frames to + // draw them on the overlay. + drawingOverlay.isFrontCameraOn = !isFrontCameraOn + isFrontCameraOn = !isFrontCameraOn + } + + val depthMapDisplayFAB = findViewById( R.id.depth_map_toggle_fab ) + depthMapDisplayFAB.setOnClickListener { + if ( isDepthMapDisplayed ) { + drawingOverlay.visibility = View.GONE + } + // Alert the FrameAnalyser to stop computing the depth maps. + frameAnalyser.isComputingDepthMap = !isDepthMapDisplayed + // Alert the DrawingOverlay to stop drawing any depth maps ( if they were to be drawn ). + drawingOverlay.isShowingDepthMap = !isDepthMapDisplayed + isDepthMapDisplayed = !isDepthMapDisplayed + depthMapDisplayFAB.backgroundTintList = + ColorStateList.valueOf( if ( isDepthMapDisplayed ) { Color.GREEN } else { Color.WHITE } ) + val message = if ( isDepthMapDisplayed ) { "Displaying Depth map..." } else { "Displaying Camera Feed..." } + Toast.makeText( this , message , Toast.LENGTH_LONG ).show() + } + depthMapDisplayFAB.backgroundTintList = ColorStateList.valueOf( Color.WHITE ) + + // Request the CAMERA permission as we'll require it for displaying the camera preview. + // See https://developer.android.com/training/permissions/requesting#allow-system-manage-request-code + if (ActivityCompat.checkSelfPermission( this , Manifest.permission.CAMERA) + != PackageManager.PERMISSION_GRANTED ) { + requestCameraPermission() + } + else { + setupCameraProvider( CameraSelector.LENS_FACING_FRONT ) + } + + } + + + private fun requestCameraPermission() { + Logger.logInfo( "Requesting camera permission" ) + requestCameraPermissionLauncher.launch( Manifest.permission.CAMERA ) + } + + + private val requestCameraPermissionLauncher = registerForActivityResult( + ActivityResultContracts.RequestPermission() ) { + isGranted : Boolean -> + if ( isGranted ) { + Logger.logInfo( "Camera permission granted by user." ) + setupCameraProvider( CameraSelector.LENS_FACING_FRONT ) + } + else { + Logger.logInfo( "Camera permission denied by user." ) + val alertDialog = AlertDialog.Builder( this ).apply { + setTitle( "Permissions" ) + setMessage( "The app requires the camera permission to function." ) + setPositiveButton( "GRANT") { dialog, _ -> + dialog.dismiss() + requestCameraPermission() + } + setNegativeButton( "CLOSE" ) { dialog, _ -> + dialog.dismiss() + finish() + } + setCancelable( false ) + create() + } + alertDialog.show() + } + } + + + // Setup the PreviewView for live camera feed. + // See the docs -> https://developer.android.com/training/camerax/preview + // and https://developer.android.com/training/camerax/analyze + private fun setupCameraProvider( cameraFacing : Int ) { + cameraProviderListenableFuture = ProcessCameraProvider.getInstance( this ) + cameraProviderListenableFuture.addListener({ + try { + val cameraProvider: ProcessCameraProvider = cameraProviderListenableFuture.get() + bindPreview( cameraProvider , cameraFacing ) + } + catch (e: ExecutionException) { + Logger.logError( e.message!! ) + } + catch (e: InterruptedException) { + Logger.logError( e.message!! ) + } + }, ContextCompat.getMainExecutor( this )) + } + + + private fun bindPreview( cameraProvider: ProcessCameraProvider , lensFacing : Int ) { + // Unbind any previous use-cases as we'll attach them once again. + if ( preview != null && frameAnalysis != null ) { + cameraProvider.unbind( preview , frameAnalysis ) + } + + Logger.logInfo( "Setting camera with ${ + if ( lensFacing == CameraSelector.LENS_FACING_FRONT ) { "front" } + else { "rear" } + } lens facing" ) + + preview = Preview.Builder().build() + val cameraSelector = CameraSelector.Builder() + .requireLensFacing( lensFacing ) + .build() + preview!!.setSurfaceProvider(previewView.surfaceProvider) + + // Set the resolution which is the closest to the screen size. + val displayMetrics = resources.displayMetrics + val screenSize = Size( displayMetrics.widthPixels, displayMetrics.heightPixels ) + Logger.logInfo( "Screen size is $screenSize" ) + + frameAnalysis = ImageAnalysis.Builder() + .setTargetResolution( screenSize ) + .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST) + .build() + + frameAnalysis!!.setAnalyzer( Executors.newSingleThreadExecutor() , frameAnalyser ) + cameraProvider.bindToLifecycle( + (this as LifecycleOwner), + cameraSelector, + frameAnalysis, + preview + ) + } + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt new file mode 100644 index 0000000..b556545 --- /dev/null +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt @@ -0,0 +1,151 @@ +/* + * Copyright 2021 Shubham Panchal + * 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. + */ +package com.shubham0204.ml.depthestimation + +import android.content.Context +import android.graphics.Bitmap +import android.os.Build +import org.tensorflow.lite.DataType +import org.tensorflow.lite.Interpreter +import org.tensorflow.lite.gpu.CompatibilityList +import org.tensorflow.lite.gpu.GpuDelegate +import org.tensorflow.lite.nnapi.NnApiDelegate +import org.tensorflow.lite.support.common.FileUtil +import org.tensorflow.lite.support.common.TensorOperator +import org.tensorflow.lite.support.common.TensorProcessor +import org.tensorflow.lite.support.common.ops.NormalizeOp +import org.tensorflow.lite.support.image.ImageProcessor +import org.tensorflow.lite.support.image.TensorImage +import org.tensorflow.lite.support.image.ops.ResizeOp +import org.tensorflow.lite.support.tensorbuffer.TensorBuffer +import org.tensorflow.lite.support.tensorbuffer.TensorBufferFloat + +// Helper class for the MiDAS TFlite model +class MiDASModel( context: Context ) { + + // See the `app/src/main/assets` folder for the TFLite model + private val modelFileName = "depth_model.tflite" + private var interpreter : Interpreter + private val NUM_THREADS = 4 + + // These values are taken from the Python file -> + // https://github.com/isl-org/MiDaS/blob/master/mobile/android/models/src/main/assets/run_tflite.py + private val inputImageDim = 256 + private val mean = floatArrayOf( 123.675f , 116.28f , 103.53f ) + private val std = floatArrayOf( 58.395f , 57.12f , 57.375f ) + + // Input tensor processor for MiDAS + // 1. Resize the image to ( 256 , 256 ) + // 2. Normalize using the given mean and std for each channel. + private val inputTensorProcessor = ImageProcessor.Builder() + .add( ResizeOp( inputImageDim , inputImageDim , ResizeOp.ResizeMethod.BILINEAR ) ) + .add( NormalizeOp( mean , std ) ) + .build() + + // Output tensor processor for MiDAS + // Perform min-max scaling for the outputs. See `MinMaxScalingOp` class. + private val outputTensorProcessor = TensorProcessor.Builder() + .add( MinMaxScalingOp() ) + .build() + + + + init { + // Initialize TFLite Interpreter + val interpreterOptions = Interpreter.Options().apply { + // Add the GPU Delegate if supported. + // See -> https://www.tensorflow.org/lite/performance/gpu#android + if ( CompatibilityList().isDelegateSupportedOnThisDevice ) { + Logger.logInfo( "GPU Delegate is supported on this device." ) + addDelegate( GpuDelegate( CompatibilityList().bestOptionsForThisDevice )) + } + else { + // Number of threads for computation + setNumThreads( NUM_THREADS ) + } + // Add the NNApiDelegate if supported. + // See -> https://www.tensorflow.org/lite/performance/nnapi#initializing_the_nnapi_delegate + if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.P ) { + Logger.logInfo( "NNAPI is supported on this device." ) + addDelegate( NnApiDelegate() ) + } + } + interpreter = Interpreter(FileUtil.loadMappedFile( context, modelFileName ) , interpreterOptions ) + Logger.logInfo( "TFLite interpreter created." ) + } + + + fun getDepthMap( inputImage : Bitmap ) : Bitmap { + return run( inputImage ) + } + + + private fun run( inputImage : Bitmap ): Bitmap { + // Note: The model takes in a RGB image ( of shape ( 256 , 256 , 3 ) ) and + // outputs a depth map of shape ( 256 , 256 , 1 ) + // Create a tensor of shape ( 1 , inputImageDim , inputImageDim , 3 ) from the given Bitmap. + // Then perform operations on the tensor as described by `inputTensorProcessor`. + var inputTensor = TensorImage.fromBitmap( inputImage ) + + val t1 = System.currentTimeMillis() + inputTensor = inputTensorProcessor.process( inputTensor ) + + // Output tensor of shape ( 256 , 256 , 1 ) and data type float32 + var outputTensor = TensorBufferFloat.createFixedSize( + intArrayOf( inputImageDim , inputImageDim , 1 ) , DataType.FLOAT32 ) + + // Perform inference on the MiDAS model + interpreter.run( inputTensor.buffer, outputTensor.buffer ) + + // Perform operations on the output tensor as described by `outputTensorProcessor`. + outputTensor = outputTensorProcessor.process( outputTensor ) + + Logger.logInfo( "MiDaS inference speed: ${System.currentTimeMillis() - t1}") + + // Create a Bitmap from the depth map which will be displayed on the screen. + return BitmapUtils.byteBufferToBitmap( outputTensor.floatArray , inputImageDim ) + } + + + // Post processing operation for MiDAS + // Apply min-max scaling to the outputs of the model and bring them in the range [ 0 , 255 ]. + // Also, we apply a transformation which changes the data type from `int` to `uint` in Python. + // As unsigned integers aren't supported in Java, we add 255 + pixel if pixel < 0 + class MinMaxScalingOp : TensorOperator { + + override fun apply( input : TensorBuffer?): TensorBuffer { + val values = input!!.floatArray + // Compute min and max of the output + val max = values.maxOrNull()!! + val min = values.minOrNull()!! + for ( i in values.indices ) { + // Normalize the values and scale them by a factor of 255 + var p = ((( values[ i ] - min ) / ( max - min )) * 255).toInt() + if ( p < 0 ) { + p += 255 + } + values[ i ] = p.toFloat() + } + // Convert the normalized values to the TensorBuffer and load the values in it. + val output = TensorBufferFloat.createFixedSize( input.shape , DataType.FLOAT32 ) + output.loadArray( values ) + return output + } + + } + + + +} \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/depth_estimation/app/src/main/res/drawable-v24/ic_launcher_foreground.xml new file mode 100644 index 0000000..2b068d1 --- /dev/null +++ b/depth_estimation/app/src/main/res/drawable-v24/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/drawable/depth_map_toggle_icon.xml b/depth_estimation/app/src/main/res/drawable/depth_map_toggle_icon.xml new file mode 100644 index 0000000..b4d0af2 --- /dev/null +++ b/depth_estimation/app/src/main/res/drawable/depth_map_toggle_icon.xml @@ -0,0 +1,5 @@ + + + diff --git a/depth_estimation/app/src/main/res/drawable/flip_camera_icon.xml b/depth_estimation/app/src/main/res/drawable/flip_camera_icon.xml new file mode 100644 index 0000000..6f479a6 --- /dev/null +++ b/depth_estimation/app/src/main/res/drawable/flip_camera_icon.xml @@ -0,0 +1,5 @@ + + + diff --git a/depth_estimation/app/src/main/res/drawable/ic_launcher_background.xml b/depth_estimation/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..07d5da9 --- /dev/null +++ b/depth_estimation/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/depth_estimation/app/src/main/res/layout/activity_main.xml b/depth_estimation/app/src/main/res/layout/activity_main.xml new file mode 100644 index 0000000..7571ef1 --- /dev/null +++ b/depth_estimation/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,53 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 0000000..eca70cf --- /dev/null +++ b/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 0000000..eca70cf --- /dev/null +++ b/depth_estimation/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..c209e78ecd372343283f4157dcfd918ec5165bb3 GIT binary patch literal 1404 zcmV-?1%vuhNk&F=1pok7MM6+kP&il$0000G0000-002h-06|PpNX!5L00Dqw+t%{r zzW2vH!KF=w&cMnnN@{whkTw+#mAh0SV?YL=)3MimFYCWp#fpdtz~8$hD5VPuQgtcN zXl<@<#Cme5f5yr2h%@8TWh?)bSK`O z^Z@d={gn7J{iyxL_y_%J|L>ep{dUxUP8a{byupH&!UNR*OutO~0{*T4q5R6@ApLF! z5{w?Z150gC7#>(VHFJZ-^6O@PYp{t!jH(_Z*nzTK4 zkc{fLE4Q3|mA2`CWQ3{8;gxGizgM!zccbdQoOLZc8hThi-IhN90RFT|zlxh3Ty&VG z?Fe{#9RrRnxzsu|Lg2ddugg7k%>0JeD+{XZ7>Z~{=|M+sh1MF7~ zz>To~`~LVQe1nNoR-gEzkpe{Ak^7{{ZBk2i_<+`Bq<^GB!RYG+z)h;Y3+<{zlMUYd zrd*W4w&jZ0%kBuDZ1EW&KLpyR7r2=}fF2%0VwHM4pUs}ZI2egi#DRMYZPek*^H9YK zay4Iy3WXFG(F14xYsoDA|KXgGc5%2DhmQ1gFCkrgHBm!lXG8I5h*uf{rn48Z!_@ z4Bk6TJAB2CKYqPjiX&mWoW>OPFGd$wqroa($ne7EUK;#3VYkXaew%Kh^3OrMhtjYN?XEoY`tRPQsAkH-DSL^QqyN0>^ zmC>{#F14jz4GeW{pJoRpLFa_*GI{?T93^rX7SPQgT@LbLqpNA}<@2wH;q493)G=1Y z#-sCiRNX~qf3KgiFzB3I>4Z%AfS(3$`-aMIBU+6?gbgDb!)L~A)je+;fR0jWLL-Fu z4)P{c7{B4Hp91&%??2$v9iRSFnuckHUm}or9seH6 z>%NbT+5*@L5(I9j@06@(!{ZI?U0=pKn8uwIg&L{JV14+8s2hnvbRrU|hZCd}IJu7*;;ECgO%8_*W Kmw_-CKmY()leWbG literal 0 HcmV?d00001 diff --git a/depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/depth_estimation/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..b2dfe3d1ba5cf3ee31b3ecc1ced89044a1f3b7a9 GIT binary patch literal 2898 zcmV-Y3$650Nk&FW3jhFDMM6+kP&il$0000G0000-002h-06|PpNWB9900E$G+qN-D z+81ABX7q?;bwx%xBg?kcwr$(C-Tex-ZCkHUw(Y9#+`E5-zuONG5fgw~E2WDng@Bc@ z24xy+R1n%~6xI#u9vJ8zREI)sb<&Il(016}Z~V1n^PU3-_H17A*Bf^o)&{_uBv}Py zulRfeE8g(g6HFhk_?o_;0@tz?1I+l+Y#Q*;RVC?(ud`_cU-~n|AX-b`JHrOIqn(-t&rOg-o`#C zh0LPxmbOAEb;zHTu!R3LDh1QO zZTf-|lJNUxi-PpcbRjw3n~n-pG;$+dIF6eqM5+L();B2O2tQ~|p{PlpNcvDbd1l%c zLtXn%lu(3!aNK!V#+HNn_D3lp z2%l+hK-nsj|Bi9;V*WIcQRTt5j90A<=am+cc`J zTYIN|PsYAhJ|=&h*4wI4ebv-C=Be#u>}%m;a{IGmJDU`0snWS&$9zdrT(z8#{OZ_Y zxwJx!ZClUi%YJjD6Xz@OP8{ieyJB=tn?>zaI-4JN;rr`JQbb%y5h2O-?_V@7pG_+y z(lqAsqYr!NyVb0C^|uclHaeecG)Sz;WV?rtoqOdAAN{j%?Uo%owya(F&qps@Id|Of zo@~Y-(YmfB+chv^%*3g4k3R0WqvuYUIA+8^SGJ{2Bl$X&X&v02>+0$4?di(34{pt* zG=f#yMs@Y|b&=HyH3k4yP&goF2LJ#tBLJNNDo6lG06r}ghC-pC4Q*=x3;|+W04zte zAl>l4kzUBQFYF(E`KJy?ZXd1tnfbH+Z~SMmA21KokJNs#eqcXWKUIC>{TuoKe^vhF z);H)o`t9j~`$h1D`#bxe@E`oE`cM9w(@)5Bp8BNukIwM>wZHfd0S;5bcXA*5KT3bj zc&_~`&{z7u{Et!Z_k78H75gXf4g8<_ul!H$eVspPeU3j&&Au=2R*Zp#M9$9s;fqwgzfiX=E_?BwVcfx3tG9Q-+<5fw z%Hs64z)@Q*%s3_Xd5>S4dg$s>@rN^ixeVj*tqu3ZV)biDcFf&l?lGwsa zWj3rvK}?43c{IruV2L`hUU0t^MemAn3U~x3$4mFDxj=Byowu^Q+#wKRPrWywLjIAp z9*n}eQ9-gZmnd9Y0WHtwi2sn6n~?i#n9VN1B*074_VbZZ=WrpkMYr{RsI ztM_8X1)J*DZejxkjOTRJ&a*lrvMKBQURNP#K)a5wIitfu(CFYV4FT?LUB$jVwJSZz zNBFTWg->Yk0j&h3e*a5>B=-xM7dE`IuOQna!u$OoxLlE;WdrNlN)1 z7**de7-hZ!(%_ZllHBLg`Ir#|t>2$*xVOZ-ADZKTN?{(NUeLU9GbuG-+Axf*AZ-P1 z0ZZ*fx+ck4{XtFsbcc%GRStht@q!m*ImssGwuK+P@%gEK!f5dHymg<9nSCXsB6 zQ*{<`%^bxB($Z@5286^-A(tR;r+p7B%^%$N5h%lb*Vlz-?DL9x;!j<5>~kmXP$E}m zQV|7uv4SwFs0jUervsxVUm>&9Y3DBIzc1XW|CUZrUdb<&{@D5yuLe%Xniw^x&{A2s z0q1+owDSfc3Gs?ht;3jw49c#mmrViUfX-yvc_B*wY|Lo7; zGh!t2R#BHx{1wFXReX*~`NS-LpSX z#TV*miO^~B9PF%O0huw!1Zv>^d0G3$^8dsC6VI!$oKDKiXdJt{mGkyA`+Gwd4D-^1qtNTUK)`N*=NTG-6}=5k6suNfdLt*dt8D| z%H#$k)z#ZRcf|zDWB|pn<3+7Nz>?WW9WdkO5(a^m+D4WRJ9{wc>Y}IN)2Kbgn;_O? zGqdr&9~|$Y0tP=N(k7^Eu;iO*w+f%W`20BNo)=Xa@M_)+o$4LXJyiw{F?a633SC{B zl~9FH%?^Rm*LVz`lkULs)%idDX^O)SxQol(3jDRyBVR!7d`;ar+D7do)jQ}m`g$TevUD5@?*P8)voa?kEe@_hl{_h8j&5eB-5FrYW&*FHVt$ z$kRF9Nstj%KRzpjdd_9wO=4zO8ritN*NPk_9avYrsF(!4))tm{Ga#OY z(r{0buexOzu7+rw8E08Gxd`LTOID{*AC1m*6Nw@osfB%0oBF5sf<~wH1kL;sd zo)k6^VyRFU`)dt*iX^9&QtWbo6yE8XXH?`ztvpiOLgI3R+=MOBQ9=rMVgi<*CU%+d1PQQ0a1U=&b0vkF207%xU0ssI2 literal 0 HcmV?d00001 diff --git a/depth_estimation/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/depth_estimation/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..4f0f1d64e58ba64d180ce43ee13bf9a17835fbca GIT binary patch literal 982 zcmV;{11bDcNk&G_0{{S5MM6+kP&il$0000G0000l001ul06|PpNU8t;00Dqo+t#w^ z^1csucXz7-Qrhzl9HuHB%l>&>1tG2^vb*E&k^T3$FG1eQZ51g$uv4V+kI`0<^1Z@N zk?Jjh$olyC%l>)Xq;7!>{iBj&BjJ`P&$fsCfpve_epJOBkTF?nu-B7D!hO=2ZR}

C%4 zc_9eOXvPbC4kzU8YowIA8cW~Uv|eB&yYwAObSwL2vY~UYI7NXPvf3b+c^?wcs~_t{ ze_m66-0)^{JdOMKPwjpQ@Sna!*?$wTZ~su*tNv7o!gXT!GRgivP}ec?5>l1!7<(rT zds|8x(qGc673zrvYIz;J23FG{9nHMnAuP}NpAED^laz3mAN1sy+NXK)!6v1FxQ;lh zOBLA>$~P3r4b*NcqR;y6pwyhZ3_PiDb|%n1gGjl3ZU}ujInlP{eks-#oA6>rh&g+!f`hv#_%JrgYPu z(U^&XLW^QX7F9Z*SRPpQl{B%x)_AMp^}_v~?j7 zapvHMKxSf*Mtyx8I}-<*UGn3)oHd(nn=)BZ`d$lDBwq_GL($_TPaS{UeevT(AJ`p0 z9%+hQb6z)U9qjbuXjg|dExCLjpS8$VKQ55VsIC%@{N5t{NsW)=hNGI`J=x97_kbz@ E0Of=7!TQj4N+cqN`nQhxvX7dAV-`K|Ub$-q+H-5I?Tx0g9jWxd@A|?POE8`3b8fO$T))xP* z(X?&brZw({`)WU&rdAs1iTa0x6F@PIxJ&&L|dpySV!ID|iUhjCcKz(@mE z!x@~W#3H<)4Ae(4eQJRk`Iz3<1)6^m)0b_4_TRZ+cz#eD3f8V;2r-1fE!F}W zEi0MEkTTx}8i1{`l_6vo0(Vuh0HD$I4SjZ=?^?k82R51bC)2D_{y8mi_?X^=U?2|F{Vr7s!k(AZC$O#ZMyavHhlQ7 zUR~QXuH~#o#>(b$u4?s~HLF*3IcF7023AlwAYudn0FV~|odGH^05AYPEfR)8p`i{n zwg3zPVp{+wOsxKc>)(pMupKF!Y2HoUqQ3|Yu|8lwR=?5zZuhG6J?H`bSNk_wPoM{u zSL{c@pY7+c2kck>`^q1^^gR0QB7Y?KUD{vz-uVX~;V-rW)PDcI)$_UjgVV?S?=oLR zf4}zz{#*R_{LkiJ#0RdQLNC^2Vp%JPEUvG9ra2BVZ92(p9h7Ka@!yf9(lj#}>+|u* z;^_?KWdzkM`6gqPo9;;r6&JEa)}R3X{(CWv?NvgLeOTq$cZXqf7|sPImi-7cS8DCN zGf;DVt3Am`>hH3{4-WzH43Ftx)SofNe^-#|0HdCo<+8Qs!}TZP{HH8~z5n`ExcHuT zDL1m&|DVpIy=xsLO>8k92HcmfSKhflQ0H~9=^-{#!I1g(;+44xw~=* zxvNz35vfsQE)@)Zsp*6_GjYD};Squ83<_?^SbALb{a`j<0Gn%6JY!zhp=Fg}Ga2|8 z52e1WU%^L1}15Ex0fF$e@eCT(()_P zvV?CA%#Sy08_U6VPt4EtmVQraWJX` zh=N|WQ>LgrvF~R&qOfB$!%D3cGv?;Xh_z$z7k&s4N)$WYf*k=|*jCEkO19{h_(%W4 zPuOqbCw`SeAX*R}UUsbVsgtuG?xs(#Ikx9`JZoQFz0n*7ZG@Fv@kZk`gzO$HoA9kN z8U5{-yY zvV{`&WKU2$mZeoBmiJrEdzUZAv1sRxpePdg1)F*X^Y)zp^Y*R;;z~vOv-z&)&G)JQ{m!C9cmziu1^nHA z`#`0c>@PnQ9CJKgC5NjJD8HM3|KC(g5nnCq$n0Gsu_DXk36@ql%npEye|?%RmG)

FJ$wK}0tWNB{uH;AM~i literal 0 HcmV?d00001 diff --git a/depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..948a3070fe34c611c42c0d3ad3013a0dce358be0 GIT binary patch literal 1900 zcmV-y2b1_xNk&Fw2LJ$9MM6+kP&il$0000G0001A003VA06|PpNH75a00DqwTbm-~ zullQTcXxO9ki!OCRx^i?oR|n!<8G0=kI^!JSjFi-LL*`V;ET0H2IXfU0*i>o6o6Gy zRq6Ap5(_{XLdXcL-MzlN`ugSdZY_`jXhcENAu)N_0?GhF))9R;E`!bo9p?g?SRgw_ zEXHhFG$0{qYOqhdX<(wE4N@es3VIo$%il%6xP9gjiBri+2pI6aY4 zJbgh-Ud|V%3O!IcHKQx1FQH(_*TK;1>FQWbt^$K1zNn^cczkBs=QHCYZ8b&l!UV{K z{L0$KCf_&KR^}&2Fe|L&?1I7~pBENnCtCuH3sjcx6$c zwqkNkru);ie``q+_QI;IYLD9OV0ZxkuyBz|5<$1BH|vtey$> z5oto4=l-R-Aaq`Dk0}o9N0VrkqW_#;!u{!bJLDq%0092{Ghe=F;(kn} z+sQ@1=UlX30+2nWjkL$B^b!H2^QYO@iFc0{(-~yXj2TWz?VG{v`Jg zg}WyYnwGgn>{HFaG7E~pt=)sOO}*yd(UU-D(E&x{xKEl6OcU?pl)K%#U$dn1mDF19 zSw@l8G!GNFB3c3VVK0?uyqN&utT-D5%NM4g-3@Sii9tSXKtwce~uF zS&Jn746EW^wV~8zdQ1XC28~kXu8+Yo9p!<8h&(Q({J*4DBglPdpe4M_mD8AguZFn~ ztiuO~{6Bx?SfO~_ZV(GIboeR9~hAym{{fV|VM=77MxDrbW6`ujX z<3HF(>Zr;#*uCvC*bpoSr~C$h?_%nXps@A)=l_;({Fo#6Y1+Zv`!T5HB+)#^-Ud_; zBwftPN=d8Vx)*O1Mj+0oO=mZ+NVH*ptNDC-&zZ7Hwho6UQ#l-yNvc0Cm+2$$6YUk2D2t#vdZX-u3>-Be1u9gtTBiMB^xwWQ_rgvGpZ6(C@e23c!^K=>ai-Rqu zhqT`ZQof;9Bu!AD(i^PCbYV%yha9zuoKMp`U^z;3!+&d@Hud&_iy!O-$b9ZLcSRh? z)R|826w}TU!J#X6P%@Zh=La$I6zXa#h!B;{qfug}O%z@K{EZECu6zl)7CiNi%xti0 zB{OKfAj83~iJvmpTU|&q1^?^cIMn2RQ?jeSB95l}{DrEPTW{_gmU_pqTc)h@4T>~& zluq3)GM=xa(#^VU5}@FNqpc$?#SbVsX!~RH*5p0p@w z;~v{QMX0^bFT1!cXGM8K9FP+=9~-d~#TK#ZE{4umGT=;dfvWi?rYj;^l_Zxywze`W z^Cr{55U@*BalS}K%Czii_80e0#0#Zkhlij4-~I@}`-JFJ7$5{>LnoJSs??J8kWVl6|8A}RCGAu9^rAsfCE=2}tHwl93t0C?#+jMpvr7O3`2=tr{Hg$=HlnjVG^ewm|Js0J*kfPa6*GhtB>`fN!m#9J(sU!?(OSfzY*zS(FJ<-Vb zfAIg+`U)YaXv#sY(c--|X zEB+TVyZ%Ie4L$gi#Fc++`h6%vzsS$pjz9aLt+ZL(g;n$Dzy5=m=_TV(3H8^C{r0xd zp#a%}ht55dOq?yhwYPrtp-m1xXp;4X;)NhxxUpgP%XTLmO zcjaFva^}dP3$&sfFTIR_jC=2pHh9kpI@2(6V*GQo7Ws)`j)hd+tr@P~gR*2gO@+1? zG<`_tB+LJuF|SZ9tIec;h%}}6WClT`L>HSW?E{Hp1h^+mlbf_$9zA>!ug>NALJsO{ mU%z=YwVD?}XMya)Bp;vlyE5&E_6!fzx9pwrdz474!~g(M6R?N? literal 0 HcmV?d00001 diff --git a/depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/depth_estimation/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..1b9a6956b3acdc11f40ce2bb3f6efbd845cc243f GIT binary patch literal 3918 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�(p-{x$&=IACIfoAR!za)F-^da-t3#0Dycnp zwO~NVXwXCl;jE<}>%@xz|=8fIJAB?>+E{7)|4l${4ngA3G|=r z2Dyv;VVWSgZx9Wj>qUjleGl3Ei9K4>h!(lPS%8VOG>Xu0%6VDz^O=bjJmuP7>DeUv zrbI}MlHB^^d?{zv6d=@_ZD2lg1&G7UjnVN{1}9WkaM3H~btX0GtSzB+tZ^qRgWo4m z!GmimlG$=wgXCnr6j@m<1gAL46#T~5Bnm=2{^@>|t&`9mkEPddj zAvG~@Tv~TAm2i%VW}R-g(Z0)z-Y|szHr@rk>4MAyG*Ma*7Yh#H7(!-5>DZ@8r;_dx z{prSe<>~099F8vsYd2xff7uAS%7{S)f(|@me3t2$iy&NEc7OUEchp@9A|X;;IA>8!oX+y(BKJ$EzV* znR$z;!L$s7uy@{OT~nG#B!NRraT8(X##Ho!0r_o@gg0CA-9H^;-uE&?$2$nHv_00o z%cbuUc-tCx$Uh&EZ4Nf4Zgqv)Y6>usG3>GeQnxx_Z6+PcbX-+ysbt1hQ`K1LDpOE? zrAhIZhSN9yVIAOa22gn577tbc&i3|3V8NWy&!tw##`}9*x}gtI^h1DzZRA>UuaJG) zaZ7j)dq!O}{?#8Y7~7i6fHh4{`pL?>-18|p!S75Y#^DM>-S3)vuZG+Q7l@ek zQP~#cBpWgg#mApc_sPYjpw8odQuRokmTkzcNl`^CcKB7e&;zViV;{Y{o^Y$%7i0m# z62%#1Lq!RC?}lK>%mp}T!3Xv;L*0v*>USLm``N%>w>@fwC+#T&Tx2bN4w(20JB}oU zuSa6v^kXi0xPs?pbaOHnyiqq6By1EZY9OZ^^QA>{q-Hsd&m`pbQ%8121aWG-F5xf zlZ%;B{;C>X19|`^_?dVyCq>n+41w7|!tUS!{9rHlbhX=SZO5CQ^;!Du_E7*`GiR^Q w)2!4MKjfSAeNo!9>IaV6aUZ*?W>} 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

UmY2RIYtNPVDpE$%vda+HD#3m z&VuXJ{BK&Qe+rBa7eq}Q(bq|tn(RrJAk|ztj2(i{d>nmQnM?;HF2k&9sA6up5tmjl z7lySlzMbifH17-m-Lwa_F&e7nOH?ESi3#ckR3tsM+jsck3`oG!uMS}|eAwVXv>}qxwq?QY%QJ0}r@^;fhuUA9W z*BVl>TGo&N004@xSiwDUXUvp51sVmqO3m)=B55aPwf@0=e}cN+$-BdKxY`YrT_4)0 z_d10#i44Q*rFr8MC>*)v$EJvz``(pb{e&*6k+b zsMz%($|1+8hn8c2?P(l@;Rb&CsZeYoCI3?2!LqjbwPXW3z4G$Qfj=cT5Yb%vY0(AX oeb?AaKtwrnc|$|zzw9vfvn^aJJ!zd)XFXqqy0000001=f@-~a#s literal 0 HcmV?d00001 diff --git a/depth_estimation/app/src/main/res/values-night/themes.xml b/depth_estimation/app/src/main/res/values-night/themes.xml new file mode 100644 index 0000000..f0cbf28 --- /dev/null +++ b/depth_estimation/app/src/main/res/values-night/themes.xml @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/values/colors.xml b/depth_estimation/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..f8c6127 --- /dev/null +++ b/depth_estimation/app/src/main/res/values/colors.xml @@ -0,0 +1,10 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/values/strings.xml b/depth_estimation/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..8d2b39a --- /dev/null +++ b/depth_estimation/app/src/main/res/values/strings.xml @@ -0,0 +1,3 @@ + + Depth Estimation + \ No newline at end of file diff --git a/depth_estimation/app/src/main/res/values/themes.xml b/depth_estimation/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..964604c --- /dev/null +++ b/depth_estimation/app/src/main/res/values/themes.xml @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/depth_estimation/build.gradle b/depth_estimation/build.gradle new file mode 100644 index 0000000..fee67c2 --- /dev/null +++ b/depth_estimation/build.gradle @@ -0,0 +1,18 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +buildscript { + repositories { + google() + mavenCentral() + } + dependencies { + classpath "com.android.tools.build:gradle:7.0.0" + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20" + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} \ No newline at end of file diff --git a/depth_estimation/gradle.properties b/depth_estimation/gradle.properties new file mode 100644 index 0000000..98bed16 --- /dev/null +++ b/depth_estimation/gradle.properties @@ -0,0 +1,21 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app"s APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true +# Automatically convert third-party libraries to use AndroidX +android.enableJetifier=true +# Kotlin code style for this project: "official" or "obsolete": +kotlin.code.style=official \ No newline at end of file diff --git a/depth_estimation/gradle/wrapper/gradle-wrapper.jar b/depth_estimation/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..e708b1c023ec8b20f512888fe07c5bd3ff77bb8f GIT binary patch literal 59203 zcma&O1CT9Y(k9%tZQHhO+qUh#ZQHhO+qmuS+qP|E@9xZO?0h@l{(r>DQ>P;GjjD{w zH}lENr;dU&FbEU?00aa80D$0M0RRB{U*7-#kbjS|qAG&4l5%47zyJ#WrfA#1$1Ctx zf&Z_d{GW=lf^w2#qRJ|CvSJUi(^E3iv~=^Z(zH}F)3Z%V3`@+rNB7gTVU{Bb~90p|f+0(v;nz01EG7yDMX9@S~__vVgv%rS$+?IH+oZ03D5zYrv|^ zC1J)SruYHmCki$jLBlTaE5&dFG9-kq3!^i>^UQL`%gn6)jz54$WDmeYdsBE9;PqZ_ zoGd=P4+|(-u4U1dbAVQrFWoNgNd;0nrghPFbQrJctO>nwDdI`Q^i0XJDUYm|T|RWc zZ3^Qgo_Qk$%Fvjj-G}1NB#ZJqIkh;kX%V{THPqOyiq)d)0+(r9o(qKlSp*hmK#iIY zA^)Vr$-Hz<#SF=0@tL@;dCQsm`V9s1vYNq}K1B)!XSK?=I1)tX+bUV52$YQu*0%fnWEukW>mxkz+%3-S!oguE8u#MGzST8_Dy^#U?fA@S#K$S@9msUiX!gd_ow>08w5)nX{-KxqMOo7d?k2&?Vf z&diGDtZr(0cwPe9z9FAUSD9KC)7(n^lMWuayCfxzy8EZsns%OEblHFSzP=cL6}?J| z0U$H!4S_TVjj<`6dy^2j`V`)mC;cB%* z8{>_%E1^FH!*{>4a7*C1v>~1*@TMcLK{7nEQ!_igZC}ikJ$*<$yHy>7)oy79A~#xE zWavoJOIOC$5b6*q*F_qN1>2#MY)AXVyr$6x4b=$x^*aqF*L?vmj>Mgv+|ITnw_BoW zO?jwHvNy^prH{9$rrik1#fhyU^MpFqF2fYEt(;4`Q&XWOGDH8k6M=%@fics4ajI;st# zCU^r1CK&|jzUhRMv;+W~6N;u<;#DI6cCw-otsc@IsN3MoSD^O`eNflIoR~l4*&-%RBYk@gb^|-JXs&~KuSEmMxB}xSb z@K76cXD=Y|=I&SNC2E+>Zg?R6E%DGCH5J1nU!A|@eX9oS(WPaMm==k2s_ueCqdZw| z&hqHp)47`c{BgwgvY2{xz%OIkY1xDwkw!<0veB#yF4ZKJyabhyyVS`gZepcFIk%e2 zTcrmt2@-8`7i-@5Nz>oQWFuMC_KlroCl(PLSodswHqJ3fn<;gxg9=}~3x_L3P`9Sn zChIf}8vCHvTriz~T2~FamRi?rh?>3bX1j}%bLH+uFX+p&+^aXbOK7clZxdU~6Uxgy z8R=obwO4dL%pmVo*Ktf=lH6hnlz_5k3cG;m8lgaPp~?eD!Yn2kf)tU6PF{kLyn|oI@eQ`F z3IF7~Blqg8-uwUuWZScRKn%c2_}dXB6Dx_&xR*n9M9LXasJhtZdr$vBY!rP{c@=)& z#!?L$2UrkvClwQO>U*fSMs67oSj2mxiJ$t;E|>q%Kh_GzzWWO&3;ufU%2z%ucBU8H z3WIwr$n)cfCXR&>tyB7BcSInK>=ByZA%;cVEJhcg<#6N{aZC4>K41XF>ZgjG`z_u& zGY?;Ad?-sgiOnI`oppF1o1Gurqbi*;#x2>+SSV6|1^G@ooVy@fg?wyf@0Y!UZ4!}nGuLeC^l)6pwkh|oRY`s1Pm$>zZ3u-83T|9 zGaKJIV3_x+u1>cRibsaJpJqhcm%?0-L;2 zitBrdRxNmb0OO2J%Y&Ym(6*`_P3&&5Bw157{o7LFguvxC$4&zTy#U=W*l&(Q2MNO} zfaUwYm{XtILD$3864IA_nn34oVa_g^FRuHL5wdUd)+W-p-iWCKe8m_cMHk+=? zeKX)M?Dt(|{r5t7IenkAXo%&EXIb-i^w+0CX0D=xApC=|Xy(`xy+QG^UyFe z+#J6h_&T5i#sV)hj3D4WN%z;2+jJcZxcI3*CHXGmOF3^)JD5j&wfX)e?-|V0GPuA+ zQFot%aEqGNJJHn$!_}#PaAvQ^{3-Ye7b}rWwrUmX53(|~i0v{}G_sI9uDch_brX&6 zWl5Ndj-AYg(W9CGfQf<6!YmY>Ey)+uYd_JNXH=>|`OH-CDCmcH(0%iD_aLlNHKH z7bcW-^5+QV$jK?R*)wZ>r9t}loM@XN&M-Pw=F#xn(;u3!(3SXXY^@=aoj70;_=QE9 zGghsG3ekq#N||u{4We_25U=y#T*S{4I{++Ku)> zQ!DZW;pVcn>b;&g2;YE#+V`v*Bl&Y-i@X6D*OpNA{G@JAXho&aOk(_j^weW{#3X5Y z%$q_wpb07EYPdmyH(1^09i$ca{O<}7) zRWncXdSPgBE%BM#by!E>tdnc$8RwUJg1*x($6$}ae$e9Knj8gvVZe#bLi!<+&BkFj zg@nOpDneyc+hU9P-;jmOSMN|*H#>^Ez#?;%C3hg_65leSUm;iz)UkW)jX#p)e&S&M z1|a?wDzV5NVnlhRBCd_;F87wp>6c<&nkgvC+!@KGiIqWY4l}=&1w7|r6{oBN8xyzh zG$b#2=RJp_iq6)#t5%yLkKx(0@D=C3w+oiXtSuaQ%I1WIb-eiE$d~!)b@|4XLy!CZ z9p=t=%3ad@Ep+<9003D2KZ5VyP~_n$=;~r&YUg5UZ0KVD&tR1DHy9x)qWtKJp#Kq# zP*8p#W(8JJ_*h_3W}FlvRam?<4Z+-H77^$Lvi+#vmhL9J zJ<1SV45xi;SrO2f=-OB(7#iNA5)x1uNC-yNxUw|!00vcW2PufRm>e~toH;M0Q85MQLWd?3O{i8H+5VkR@l9Dg-ma ze2fZ%>G(u5(k9EHj2L6!;(KZ8%8|*-1V|B#EagbF(rc+5iL_5;Eu)L4Z-V;0HfK4d z*{utLse_rvHZeQ>V5H=f78M3Ntg1BPxFCVD{HbNA6?9*^YIq;B-DJd{Ca2L#)qWP? zvX^NhFmX?CTWw&Ns}lgs;r3i+Bq@y}Ul+U%pzOS0Fcv9~aB(0!>GT0)NO?p=25LjN z2bh>6RhgqD7bQj#k-KOm@JLgMa6>%-ok1WpOe)FS^XOU{c?d5shG(lIn3GiVBxmg`u%-j=)^v&pX1JecJics3&jvPI)mDut52? z3jEA)DM%}BYbxxKrizVYwq?(P&19EXlwD9^-6J+4!}9{ywR9Gk42jjAURAF&EO|~N z)?s>$Da@ikI4|^z0e{r`J8zIs>SpM~Vn^{3fArRu;?+43>lD+^XtUcY1HidJwnR6+ z!;oG2=B6Z_=M%*{z-RaHc(n|1RTKQdNjjV!Pn9lFt^4w|AeN06*j}ZyhqZ^!-=cyGP_ShV1rGxkx8t zB;8`h!S{LD%ot``700d0@Grql(DTt4Awgmi+Yr0@#jbe=2#UkK%rv=OLqF)9D7D1j z!~McAwMYkeaL$~kI~90)5vBhBzWYc3Cj1WI0RS`z000R8-@ET0dA~*r(gSiCJmQMN&4%1D zyVNf0?}sBH8zNbBLn>~(W{d3%@kL_eQ6jEcR{l>C|JK z(R-fA!z|TTRG40|zv}7E@PqCAXP3n`;%|SCQ|ZS%ym$I{`}t3KPL&^l5`3>yah4*6 zifO#{VNz3)?ZL$be;NEaAk9b#{tV?V7 zP|wf5YA*1;s<)9A4~l3BHzG&HH`1xNr#%){4xZ!jq%o=7nN*wMuXlFV{HaiQLJ`5G zBhDi#D(m`Q1pLh@Tq+L;OwuC52RdW7b8}~60WCOK5iYMUad9}7aWBuILb({5=z~YF zt?*Jr5NG+WadM{mDL>GyiByCuR)hd zA=HM?J6l1Xv0Dl+LW@w$OTcEoOda^nFCw*Sy^I@$sSuneMl{4ys)|RY#9&NxW4S)9 zq|%83IpslTLoz~&vTo!Ga@?rj_kw{|k{nv+w&Ku?fyk4Ki4I?);M|5Axm)t+BaE)D zm(`AQ#k^DWrjbuXoJf2{Aj^KT zFb1zMSqxq|vceV+Mf-)$oPflsO$@*A0n0Z!R{&(xh8s}=;t(lIy zv$S8x>m;vQNHuRzoaOo?eiWFe{0;$s`Bc+Osz~}Van${u;g(su`3lJ^TEfo~nERfP z)?aFzpDgnLYiERsKPu|0tq4l2wT)Atr6Qb%m-AUn6HnCue*yWICp7TjW$@sO zm5rm4aTcPQ(rfi7a`xP7cKCFrJD}*&_~xgLyr^-bmsL}y;A5P|al8J3WUoBSjqu%v zxC;mK!g(7r6RRJ852Z~feoC&sD3(6}^5-uLK8o)9{8L_%%rItZK9C){UxB|;G>JbP zsRRtS4-3B*5c+K2kvmgZK8472%l>3cntWUOVHxB|{Ay~aOg5RN;{PJgeVD*H%ac+y!h#wi%o2bF2Ca8IyMyH{>4#{E_8u^@+l-+n=V}Sq?$O z{091@v%Bd*3pk0^2UtiF9Z+(a@wy6 zUdw8J*ze$K#=$48IBi1U%;hmhO>lu!uU;+RS}p&6@rQila7WftH->*A4=5W|Fmtze z)7E}jh@cbmr9iup^i%*(uF%LG&!+Fyl@LFA-}Ca#bxRfDJAiR2dt6644TaYw1Ma79 zt8&DYj31j^5WPNf5P&{)J?WlCe@<3u^78wnd(Ja4^a>{^Tw}W>|Cjt^If|7l^l)^Q zbz|7~CF(k_9~n|h;ysZ+jHzkXf(*O*@5m zLzUmbHp=x!Q|!9NVXyipZ3)^GuIG$k;D)EK!a5=8MFLI_lpf`HPKl=-Ww%z8H_0$j ztJ||IfFG1lE9nmQ0+jPQy zCBdKkjArH@K7jVcMNz);Q(Q^R{d5G?-kk;Uu_IXSyWB)~KGIizZL(^&qF;|1PI7!E zTP`%l)gpX|OFn&)M%txpQ2F!hdA~hX1Cm5)IrdljqzRg!f{mN%G~H1&oqe`5eJCIF zHdD7O;AX-{XEV(a`gBFJ9ews#CVS2y!&>Cm_dm3C8*n3MA*e67(WC?uP@8TXuMroq z{#w$%z@CBIkRM7?}Xib+>hRjy?%G!fiw8! z8(gB+8J~KOU}yO7UGm&1g_MDJ$IXS!`+*b*QW2x)9>K~Y*E&bYMnjl6h!{17_8d!%&9D`a7r&LKZjC<&XOvTRaKJ1 zUY@hl5^R&kZl3lU3njk`3dPzxj$2foOL26r(9zsVF3n_F#v)s5vv3@dgs|lP#eylq62{<-vczqP!RpVBTgI>@O6&sU>W|do17+#OzQ7o5A$ICH z?GqwqnK^n2%LR;$^oZM;)+>$X3s2n}2jZ7CdWIW0lnGK-b#EG01)P@aU`pg}th&J-TrU`tIpb5t((0eu|!u zQz+3ZiOQ^?RxxK4;zs=l8q!-n7X{@jSwK(iqNFiRColuEOg}!7cyZi`iBX4g1pNBj zAPzL?P^Ljhn;1$r8?bc=#n|Ed7wB&oHcw()&*k#SS#h}jO?ZB246EGItsz*;^&tzp zu^YJ0=lwsi`eP_pU8}6JA7MS;9pfD;DsSsLo~ogzMNP70@@;Fm8f0^;>$Z>~}GWRw!W5J3tNX*^2+1f3hz{~rIzJo z6W%J(H!g-eI_J1>0juX$X4Cl6i+3wbc~k146UIX&G22}WE>0ga#WLsn9tY(&29zBvH1$`iWtTe zG2jYl@P!P)eb<5DsR72BdI7-zP&cZNI{7q3e@?N8IKc4DE#UVr->|-ryuJXk^u^>4 z$3wE~=q390;XuOQP~TNoDR?#|NSPJ%sTMInA6*rJ%go|=YjGe!B>z6u$IhgQSwoV* zjy3F2#I>uK{42{&IqP59)Y(1*Z>>#W8rCf4_eVsH)`v!P#^;BgzKDR`ARGEZzkNX+ zJUQu=*-ol=Xqqt5=`=pA@BIn@6a9G8C{c&`i^(i+BxQO9?YZ3iu%$$da&Kb?2kCCo zo7t$UpSFWqmydXf@l3bVJ=%K?SSw)|?srhJ-1ZdFu*5QhL$~-IQS!K1s@XzAtv6*Y zl8@(5BlWYLt1yAWy?rMD&bwze8bC3-GfNH=p zynNFCdxyX?K&G(ZZ)afguQ2|r;XoV^=^(;Cku#qYn4Lus`UeKt6rAlFo_rU`|Rq z&G?~iWMBio<78of-2X(ZYHx~=U0Vz4btyXkctMKdc9UM!vYr~B-(>)(Hc|D zMzkN4!PBg%tZoh+=Gba!0++d193gbMk2&krfDgcbx0jI92cq?FFESVg0D$>F+bil} zY~$)|>1HZsX=5sAZ2WgPB5P=8X#TI+NQ(M~GqyVB53c6IdX=k>Wu@A0Svf5#?uHaF zsYn|koIi3$(%GZ2+G+7Fv^lHTb#5b8sAHSTnL^qWZLM<(1|9|QFw9pnRU{svj}_Al zL)b9>fN{QiA($8peNEJyy`(a{&uh-T4_kdZFIVsKKVM(?05}76EEz?#W za^fiZOAd14IJ4zLX-n7Lq0qlQ^lW8Cvz4UKkV9~P}>sq0?xD3vg+$4vLm~C(+ zM{-3Z#qnZ09bJ>}j?6ry^h+@PfaD7*jZxBEY4)UG&daWb??6)TP+|3#Z&?GL?1i+280CFsE|vIXQbm| zM}Pk!U`U5NsNbyKzkrul-DzwB{X?n3E6?TUHr{M&+R*2%yOiXdW-_2Yd6?38M9Vy^ z*lE%gA{wwoSR~vN0=no}tP2Ul5Gk5M(Xq`$nw#ndFk`tcpd5A=Idue`XZ!FS>Q zG^0w#>P4pPG+*NC9gLP4x2m=cKP}YuS!l^?sHSFftZy{4CoQrb_ z^20(NnG`wAhMI=eq)SsIE~&Gp9Ne0nD4%Xiu|0Fj1UFk?6avDqjdXz{O1nKao*46y zT8~iA%Exu=G#{x=KD;_C&M+Zx4+n`sHT>^>=-1YM;H<72k>$py1?F3#T1*ef9mLZw z5naLQr?n7K;2l+{_uIw*_1nsTn~I|kkCgrn;|G~##hM;9l7Jy$yJfmk+&}W@JeKcF zx@@Woiz8qdi|D%aH3XTx5*wDlbs?dC1_nrFpm^QbG@wM=i2?Zg;$VK!c^Dp8<}BTI zyRhAq@#%2pGV49*Y5_mV4+OICP|%I(dQ7x=6Ob}>EjnB_-_18*xrY?b%-yEDT(wrO z9RY2QT0`_OpGfMObKHV;QLVnrK%mc?$WAdIT`kJQT^n%GuzE7|9@k3ci5fYOh(287 zuIbg!GB3xLg$YN=n)^pHGB0jH+_iIiC=nUcD;G6LuJsjn2VI1cyZx=a?ShCsF==QK z;q~*m&}L<-cb+mDDXzvvrRsybcgQ;Vg21P(uLv5I+eGc7o7tc6`;OA9{soHFOz zT~2?>Ts}gprIX$wRBb4yE>ot<8+*Bv`qbSDv*VtRi|cyWS>)Fjs>fkNOH-+PX&4(~ z&)T8Zam2L6puQl?;5zg9h<}k4#|yH9czHw;1jw-pwBM*O2hUR6yvHATrI%^mvs9q_ z&ccT0>f#eDG<^WG^q@oVqlJrhxH)dcq2cty@l3~|5#UDdExyXUmLQ}f4#;6fI{f^t zDCsgIJ~0`af%YR%Ma5VQq-p21k`vaBu6WE?66+5=XUd%Ay%D$irN>5LhluRWt7 zov-=f>QbMk*G##&DTQyou$s7UqjjW@k6=!I@!k+S{pP8R(2=e@io;N8E`EOB;OGoI zw6Q+{X1_I{OO0HPpBz!X!@`5YQ2)t{+!?M_iH25X(d~-Zx~cXnS9z>u?+If|iNJbx zyFU2d1!ITX64D|lE0Z{dLRqL1Ajj=CCMfC4lD3&mYR_R_VZ>_7_~|<^o*%_&jevU+ zQ4|qzci=0}Jydw|LXLCrOl1_P6Xf@c0$ieK2^7@A9UbF{@V_0p%lqW|L?5k>bVM8|p5v&2g;~r>B8uo<4N+`B zH{J)h;SYiIVx@#jI&p-v3dwL5QNV1oxPr8J%ooezTnLW>i*3Isb49%5i!&ac_dEXv zvXmVUck^QHmyrF8>CGXijC_R-y(Qr{3Zt~EmW)-nC!tiH`wlw5D*W7Pip;T?&j%kX z6DkZX4&}iw>hE(boLyjOoupf6JpvBG8}jIh!!VhnD0>}KSMMo{1#uU6kiFcA04~|7 zVO8eI&x1`g4CZ<2cYUI(n#wz2MtVFHx47yE5eL~8bot~>EHbevSt}LLMQX?odD{Ux zJMnam{d)W4da{l7&y-JrgiU~qY3$~}_F#G7|MxT)e;G{U`In&?`j<5D->}cb{}{T(4DF0BOk-=1195KB-E*o@c?`>y#4=dMtYtSY=&L{!TAjFVcq0y@AH`vH! z$41+u!Ld&}F^COPgL(EE{0X7LY&%D7-(?!kjFF7=qw<;`V{nwWBq<)1QiGJgUc^Vz ztMUlq1bZqKn17|6x6iAHbWc~l1HcmAxr%$Puv!znW)!JiukwIrqQ00|H$Z)OmGG@= zv%A8*4cq}(?qn4rN6o`$Y))(MyXr8R<2S^J+v(wmFmtac!%VOfN?&(8Nr!T@kV`N; z*Q33V3t`^rN&aBiHet)18wy{*wi1=W!B%B-Q6}SCrUl$~Hl{@!95ydml@FK8P=u4s z4e*7gV2s=YxEvskw2Ju!2%{8h01rx-3`NCPc(O zH&J0VH5etNB2KY6k4R@2Wvl^Ck$MoR3=)|SEclT2ccJ!RI9Nuter7u9@;sWf-%um;GfI!=eEIQ2l2p_YWUd{|6EG ze{yO6;lMc>;2tPrsNdi@&1K6(1;|$xe8vLgiouj%QD%gYk`4p{Ktv9|j+!OF-P?@p z;}SV|oIK)iwlBs+`ROXkhd&NK zzo__r!B>tOXpBJMDcv!Mq54P+n4(@dijL^EpO1wdg~q+!DT3lB<>9AANSe!T1XgC=J^)IP0XEZ()_vpu!!3HQyJhwh?r`Ae%Yr~b% zO*NY9t9#qWa@GCPYOF9aron7thfWT`eujS4`t2uG6)~JRTI;f(ZuoRQwjZjp5Pg34 z)rp$)Kr?R+KdJ;IO;pM{$6|2y=k_siqvp%)2||cHTe|b5Ht8&A{wazGNca zX$Ol?H)E_R@SDi~4{d-|8nGFhZPW;Cts1;08TwUvLLv&_2$O6Vt=M)X;g%HUr$&06 zISZb(6)Q3%?;3r~*3~USIg=HcJhFtHhIV(siOwV&QkQe#J%H9&E21!C*d@ln3E@J* zVqRO^<)V^ky-R|%{(9`l-(JXq9J)1r$`uQ8a}$vr9E^nNiI*thK8=&UZ0dsFN_eSl z(q~lnD?EymWLsNa3|1{CRPW60>DSkY9YQ;$4o3W7Ms&@&lv9eH!tk~N&dhqX&>K@} zi1g~GqglxkZ5pEFkllJ)Ta1I^c&Bt6#r(QLQ02yHTaJB~- zCcE=5tmi`UA>@P=1LBfBiqk)HB4t8D?02;9eXj~kVPwv?m{5&!&TFYhu>3=_ zsGmYZ^mo*-j69-42y&Jj0cBLLEulNRZ9vXE)8~mt9C#;tZs;=#M=1*hebkS;7(aGf zcs7zH(I8Eui9UU4L--))yy`&d&$In&VA2?DAEss4LAPCLd>-$i?lpXvn!gu^JJ$(DoUlc6wE98VLZ*z`QGQov5l4Fm_h?V-;mHLYDVOwKz7>e4+%AzeO>P6v}ndPW| zM>m#6Tnp7K?0mbK=>gV}=@k*0Mr_PVAgGMu$j+pWxzq4MAa&jpCDU&-5eH27Iz>m^ zax1?*HhG%pJ((tkR(V(O(L%7v7L%!_X->IjS3H5kuXQT2!ow(;%FDE>16&3r){!ex zhf==oJ!}YU89C9@mfDq!P3S4yx$aGB?rbtVH?sHpg?J5C->!_FHM%Hl3#D4eplxzQ zRA+<@LD%LKSkTk2NyWCg7u=$%F#;SIL44~S_OGR}JqX}X+=bc@swpiClB`Zbz|f!4 z7Ysah7OkR8liXfI`}IIwtEoL}(URrGe;IM8%{>b1SsqXh)~w}P>yiFRaE>}rEnNkT z!HXZUtxUp1NmFm)Dm@-{FI^aRQqpSkz}ZSyKR%Y}YHNzBk)ZIp} zMtS=aMvkgWKm9&oTcU0?S|L~CDqA+sHpOxwnswF-fEG)cXCzUR?ps@tZa$=O)=L+5 zf%m58cq8g_o}3?Bhh+c!w4(7AjxwQ3>WnVi<{{38g7yFboo>q|+7qs<$8CPXUFAN< zG&}BHbbyQ5n|qqSr?U~GY{@GJ{(Jny{bMaOG{|IkUj7tj^9pa9|FB_<+KHLxSxR;@ zHpS$4V)PP+tx}22fWx(Ku9y+}Ap;VZqD0AZW4gCDTPCG=zgJmF{|x;(rvdM|2|9a}cex6xrMkERnkE;}jvU-kmzd%_J50$M`lIPCKf+^*zL=@LW`1SaEc%=m zQ+lT06Gw+wVwvQ9fZ~#qd430v2HndFsBa9WjD0P}K(rZYdAt^5WQIvb%D^Q|pkVE^ zte$&#~zmULFACGfS#g=2OLOnIf2Of-k!(BIHjs77nr!5Q1*I9 z1%?=~#Oss!rV~?-6Gm~BWJiA4mJ5TY&iPm_$)H1_rTltuU1F3I(qTQ^U$S>%$l z)Wx1}R?ij0idp@8w-p!Oz{&*W;v*IA;JFHA9%nUvVDy7Q8woheC#|8QuDZb-L_5@R zOqHwrh|mVL9b=+$nJxM`3eE{O$sCt$UK^2@L$R(r^-_+z?lOo+me-VW=Zw z-Bn>$4ovfWd%SPY`ab-u9{INc*k2h+yH%toDHIyqQ zO68=u`N}RIIs7lsn1D){)~%>ByF<>i@qFb<-axvu(Z+6t7v<^z&gm9McRB~BIaDn$ z#xSGT!rzgad8o>~kyj#h1?7g96tOcCJniQ+*#=b7wPio>|6a1Z?_(TS{)KrPe}(8j z!#&A=k(&Pj^F;r)CI=Z{LVu>uj!_W1q4b`N1}E(i%;BWjbEcnD=mv$FL$l?zS6bW!{$7j1GR5ocn94P2u{ z70tAAcpqtQo<@cXw~@i-@6B23;317|l~S>CB?hR5qJ%J3EFgyBdJd^fHZu7AzHF(BQ!tyAz^L0`X z23S4Fe{2X$W0$zu9gm%rg~A>ijaE#GlYlrF9$ds^QtaszE#4M(OLVP2O-;XdT(XIC zatwzF*)1c+t~c{L=fMG8Z=k5lv>U0;C{caN1NItnuSMp)6G3mbahu>E#sj&oy94KC zpH}8oEw{G@N3pvHhp{^-YaZeH;K+T_1AUv;IKD<=mv^&Ueegrb!yf`4VlRl$M?wsl zZyFol(2|_QM`e_2lYSABpKR{{NlxlDSYQNkS;J66aT#MSiTx~;tUmvs-b*CrR4w=f z8+0;*th6kfZ3|5!Icx3RV11sp=?`0Jy3Fs0N4GZQMN=8HmT6%x9@{Dza)k}UwL6JT zHRDh;%!XwXr6yuuy`4;Xsn0zlR$k%r%9abS1;_v?`HX_hI|+EibVnlyE@3aL5vhQq zlIG?tN^w@0(v9M*&L+{_+RQZw=o|&BRPGB>e5=ys7H`nc8nx)|-g;s7mRc7hg{GJC zAe^vCIJhajmm7C6g! zL&!WAQ~5d_5)00?w_*|*H>3$loHrvFbitw#WvLB!JASO?#5Ig5$Ys10n>e4|3d;tS zELJ0|R4n3Az(Fl3-r^QiV_C;)lQ1_CW{5bKS15U|E9?ZgLec@%kXr84>5jV2a5v=w z?pB1GPdxD$IQL4)G||B_lI+A=08MUFFR4MxfGOu07vfIm+j=z9tp~5i_6jb`tR>qV z$#`=BQ*jpCjm$F0+F)L%xRlnS%#&gro6PiRfu^l!EVan|r3y}AHJQOORGx4~ z&<)3=K-tx518DZyp%|!EqpU!+X3Et7n2AaC5(AtrkW>_57i}$eqs$rupubg0a1+WO zGHZKLN2L0D;ab%{_S1Plm|hx8R?O14*w*f&2&bB050n!R2by zw!@XOQx$SqZ5I<(Qu$V6g>o#A!JVwErWv#(Pjx=KeS0@hxr4?13zj#oWwPS(7Ro|v z>Mp@Kmxo79q|}!5qtX2-O@U&&@6s~!I&)1WQIl?lTnh6UdKT_1R640S4~f=_xoN3- zI+O)$R@RjV$F=>Ti7BlnG1-cFKCC(t|Qjm{SalS~V-tX#+2ekRhwmN zZr`8{QF6y~Z!D|{=1*2D-JUa<(1Z=;!Ei!KiRNH?o{p5o3crFF=_pX9O-YyJchr$~ zRC`+G+8kx~fD2k*ZIiiIGR<8r&M@3H?%JVOfE>)})7ScOd&?OjgAGT@WVNSCZ8N(p zuQG~76GE3%(%h1*vUXg$vH{ua0b`sQ4f0*y=u~lgyb^!#CcPJa2mkSEHGLsnO^kb$ zru5_l#nu=Y{rSMWiYx?nO{8I!gH+?wEj~UM?IrG}E|bRIBUM>UlY<`T1EHpRr36vv zBi&dG8oxS|J$!zoaq{+JpJy+O^W(nt*|#g32bd&K^w-t>!Vu9N!k9eA8r!Xc{utY> zg9aZ(D2E0gL#W0MdjwES-7~Wa8iubPrd?8-$C4BP?*wok&O8+ykOx{P=Izx+G~hM8 z*9?BYz!T8~dzcZr#ux8kS7u7r@A#DogBH8km8Ry4slyie^n|GrTbO|cLhpqgMdsjX zJ_LdmM#I&4LqqsOUIXK8gW;V0B(7^$y#h3h>J0k^WJfAMeYek%Y-Dcb_+0zPJez!GM zAmJ1u;*rK=FNM0Nf}Y!!P9c4)HIkMnq^b;JFd!S3?_Qi2G#LIQ)TF|iHl~WKK6JmK zbv7rPE6VkYr_%_BT}CK8h=?%pk@3cz(UrZ{@h40%XgThP*-Oeo`T0eq9 zA8BnWZKzCy5e&&_GEsU4*;_k}(8l_&al5K-V*BFM=O~;MgRkYsOs%9eOY6s6AtE*<7GQAR2ulC3RAJrG_P1iQK5Z~&B z&f8X<>yJV6)oDGIlS$Y*D^Rj(cszTy5c81a5IwBr`BtnC6_e`ArI8CaTX_%rx7;cn zR-0?J_LFg*?(#n~G8cXut(1nVF0Oka$A$1FGcERU<^ggx;p@CZc?3UB41RY+wLS`LWFNSs~YP zuw1@DNN3lTd|jDL7gjBsd9}wIw}4xT2+8dBQzI00m<@?c2L%>}QLfK5%r!a-iII`p zX@`VEUH)uj^$;7jVUYdADQ2k*!1O3WdfgF?OMtUXNpQ1}QINamBTKDuv19^{$`8A1 zeq%q*O0mi@(%sZU>Xdb0Ru96CFqk9-L3pzLVsMQ`Xpa~N6CR{9Rm2)A|CI21L(%GW zh&)Y$BNHa=FD+=mBw3{qTgw)j0b!Eahs!rZnpu)z!!E$*eXE~##yaXz`KE5(nQM`s zD!$vW9XH)iMxu9R>r$VlLk9oIR%HxpUiW=BK@4U)|1WNQ=mz9a z^!KkO=>GaJ!GBXm{KJj^;kh-MkUlEQ%lza`-G&}C5y1>La1sR6hT=d*NeCnuK%_LV zOXt$}iP6(YJKc9j-Fxq~*ItVUqljQ8?oaysB-EYtFQp9oxZ|5m0^Hq(qV!S+hq#g( z?|i*H2MIr^Kxgz+3vIljQ*Feejy6S4v~jKEPTF~Qhq!(ms5>NGtRgO5vfPPc4Z^AM zTj!`5xEreIN)vaNxa|q6qWdg>+T`Ol0Uz)ckXBXEGvPNEL3R8hB3=C5`@=SYgAju1 z!)UBr{2~=~xa{b8>x2@C7weRAEuatC)3pkRhT#pMPTpSbA|tan%U7NGMvzmF?c!V8 z=pEWxbdXbTAGtWTyI?Fml%lEr-^AE}w#l(<7OIw;ctw}imYax&vR4UYNJZK6P7ZOd zP87XfhnUHxCUHhM@b*NbTi#(-8|wcv%3BGNs#zRCVV(W?1Qj6^PPQa<{yaBwZ`+<`w|;rqUY_C z&AeyKwwf*q#OW-F()lir=T^<^wjK65Lif$puuU5+tk$;e_EJ;Lu+pH>=-8=PDhkBg z8cWt%@$Sc#C6F$Vd+0507;{OOyT7Hs%nKS88q-W!$f~9*WGBpHGgNp}=C*7!RiZ5s zn1L_DbKF@B8kwhDiLKRB@lsXVVLK|ph=w%_`#owlf@s@V(pa`GY$8h%;-#h@TsO|Y8V=n@*!Rog7<7Cid%apR|x zOjhHCyfbIt%+*PCveTEcuiDi%Wx;O;+K=W?OFUV%)%~6;gl?<0%)?snDDqIvkHF{ zyI02)+lI9ov42^hL>ZRrh*HhjF9B$A@=H94iaBESBF=eC_KT$8A@uB^6$~o?3Wm5t1OIaqF^~><2?4e3c&)@wKn9bD? zoeCs;H>b8DL^F&>Xw-xjZEUFFTv>JD^O#1E#)CMBaG4DX9bD(Wtc8Rzq}9soQ8`jf zeSnHOL}<+WVSKp4kkq&?SbETjq6yr@4%SAqOG=9E(3YeLG9dtV+8vmzq+6PFPk{L; z(&d++iu=^F%b+ea$i2UeTC{R*0Isk;vFK!no<;L+(`y`3&H-~VTdKROkdyowo1iqR zbVW(3`+(PQ2>TKY>N!jGmGo7oeoB8O|P_!Ic@ zZ^;3dnuXo;WJ?S+)%P>{Hcg!Jz#2SI(s&dY4QAy_vRlmOh)QHvs_7c&zkJCmJGVvV zX;Mtb>QE+xp`KyciG$Cn*0?AK%-a|=o!+7x&&yzHQOS>8=B*R=niSnta^Pxp1`=md z#;$pS$4WCT?mbiCYU?FcHGZ#)kHVJTTBt^%XE(Q};aaO=Zik0UgLcc0I(tUpt(>|& zcxB_|fxCF7>&~5eJ=Dpn&5Aj{A^cV^^}(7w#p;HG&Q)EaN~~EqrE1qKrMAc&WXIE;>@<&)5;gD2?={Xf@Mvn@OJKw=8Mgn z!JUFMwD+s==JpjhroT&d{$kQAy%+d`a*XxDEVxy3`NHzmITrE`o!;5ClXNPb4t*8P zzAivdr{j_v!=9!^?T3y?gzmqDWX6mkzhIzJ-3S{T5bcCFMr&RPDryMcdwbBuZbsgN zGrp@^i?rcfN7v0NKGzDPGE#4yszxu=I_`MI%Z|10nFjU-UjQXXA?k8Pk|OE<(?ae) zE%vG#eZAlj*E7_3dx#Zz4kMLj>H^;}33UAankJiDy5ZvEhrjr`!9eMD8COp}U*hP+ zF}KIYx@pkccIgyxFm#LNw~G&`;o&5)2`5aogs`1~7cMZQ7zj!%L4E`2yzlQN6REX20&O<9 zKV6fyr)TScJPPzNTC2gL+0x#=u>(({{D7j)c-%tvqls3#Y?Z1m zV5WUE)zdJ{$p>yX;^P!UcXP?UD~YM;IRa#Rs5~l+*$&nO(;Ers`G=0D!twR(0GF@c zHl9E5DQI}Oz74n zfKP>&$q0($T4y$6w(p=ERAFh+>n%iaeRA%!T%<^+pg?M)@ucY<&59$x9M#n+V&>}=nO9wCV{O~lg&v#+jcUj(tQ z`0u1YH)-`U$15a{pBkGyPL0THv1P|4e@pf@3IBZS4dVJPo#H>pWq%Lr0YS-SeWash z8R7=jb28KPMI|_lo#GEO|5B?N_e``H*23{~a!AmUJ+fb4HX-%QI@lSEUxKlGV7z7Q zSKw@-TR>@1RL%w{x}dW#k1NgW+q4yt2Xf1J62Bx*O^WG8OJ|FqI4&@d3_o8Id@*)4 zYrk=>@!wv~mh7YWv*bZhxqSmFh2Xq)o=m;%n$I?GSz49l1$xRpPu_^N(vZ>*>Z<04 z2+rP70oM=NDysd!@fQdM2OcyT?3T^Eb@lIC-UG=Bw{BjQ&P`KCv$AcJ;?`vdZ4){d z&gkoUK{$!$$K`3*O-jyM1~p-7T*qb)Ys>Myt^;#1&a%O@x8A+E>! zY8=eD`ZG)LVagDLBeHg>=atOG?Kr%h4B%E6m@J^C+U|y)XX@f z8oyJDW|9g=<#f<{JRr{y#~euMnv)`7j=%cHWLc}ngjq~7k**6%4u>Px&W%4D94(r* z+akunK}O0DC2A%Xo9jyF;DobX?!1I(7%}@7F>i%&nk*LMO)bMGg2N+1iqtg+r(70q zF5{Msgsm5GS7DT`kBsjMvOrkx&|EU!{{~gL4d2MWrAT=KBQ-^zQCUq{5PD1orxlIL zq;CvlWx#f1NWvh`hg011I%?T_s!e38l*lWVt|~z-PO4~~1g)SrJ|>*tXh=QfXT)%( z+ex+inPvD&O4Ur;JGz>$sUOnWdpSLcm1X%aQDw4{dB!cnj`^muI$CJ2%p&-kULVCE z>$eMR36kN$wCPR+OFDM3-U(VOrp9k3)lI&YVFqd;Kpz~K)@Fa&FRw}L(SoD z9B4a+hQzZT-BnVltst&=kq6Y(f^S4hIGNKYBgMxGJ^;2yrO}P3;r)(-I-CZ)26Y6? z&rzHI_1GCvGkgy-t1E;r^3Le30|%$ebDRu2+gdLG)r=A~Qz`}~&L@aGJ{}vVs_GE* zVUjFnzHiXfKQbpv&bR&}l2bzIjAooB)=-XNcYmrGmBh(&iu@o!^hn0^#}m2yZZUK8 zufVm7Gq0y`Mj;9b>`c?&PZkU0j4>IL=UL&-Lp3j&47B5pAW4JceG{!XCA)kT<%2nqCxj<)uy6XR_uws~>_MEKPOpAQ!H zkn>FKh)<9DwwS*|Y(q?$^N!6(51O0 z^JM~Ax{AI1Oj$fs-S5d4T7Z_i1?{%0SsIuQ&r8#(JA=2iLcTN+?>wOL532%&dMYkT z*T5xepC+V6zxhS@vNbMoi|i)=rpli@R9~P!39tWbSSb904ekv7D#quKbgFEMTb48P zuq(VJ+&L8aWU(_FCD$3^uD!YM%O^K(dvy~Wm2hUuh6bD|#(I39Xt>N1Y{ZqXL`Fg6 zKQ?T2htHN!(Bx;tV2bfTtIj7e)liN-29s1kew>v(D^@)#v;}C4-G=7x#;-dM4yRWm zyY`cS21ulzMK{PoaQ6xChEZ}o_#}X-o}<&0)$1#3we?+QeLt;aVCjeA)hn!}UaKt< zat1fHEx13y-rXNMvpUUmCVzocPmN~-Y4(YJvQ#db)4|%B!rBsgAe+*yor~}FrNH08 z3V!97S}D7d$zbSD{$z;@IYMxM6aHdypIuS*pr_U6;#Y!_?0i|&yU*@16l z*dcMqDQgfNBf}?quiu4e>H)yTVfsp#f+Du0@=Kc41QockXkCkvu>FBd6Q+@FL!(Yx z2`YuX#eMEiLEDhp+9uFqME_E^faV&~9qjBHJkIp~%$x^bN=N)K@kvSVEMdDuzA0sn z88CBG?`RX1@#hQNd`o^V{37)!w|nA)QfiYBE^m=yQKv-fQF+UCMcuEe1d4BH7$?>b zJl-r9@0^Ie=)guO1vOd=i$_4sz>y3x^R7n4ED!5oXL3@5**h(xr%Hv)_gILarO46q+MaDOF%ChaymKoI6JU5Pg;7#2n9-18|S1;AK+ zgsn6;k6-%!QD>D?cFy}8F;r@z8H9xN1jsOBw2vQONVqBVEbkiNUqgw~*!^##ht>w0 zUOykwH=$LwX2j&nLy=@{hr)2O&-wm-NyjW7n~Zs9UlH;P7iP3 zI}S(r0YFVYacnKH(+{*)Tbw)@;6>%=&Th=+Z6NHo_tR|JCI8TJiXv2N7ei7M^Q+RM z?9o`meH$5Yi;@9XaNR#jIK^&{N|DYNNbtdb)XW1Lv2k{E>;?F`#Pq|&_;gm~&~Zc9 zf+6ZE%{x4|{YdtE?a^gKyzr}dA>OxQv+pq|@IXL%WS0CiX!V zm$fCePA%lU{%pTKD7|5NJHeXg=I0jL@$tOF@K*MI$)f?om)D63K*M|r`gb9edD1~Y zc|w7N)Y%do7=0{RC|AziW7#am$)9jciRJ?IWl9PE{G3U+$%FcyKs_0Cgq`=K3@ttV z9g;M!3z~f_?P%y3-ph%vBMeS@p7P&Ea8M@97+%XEj*(1E6vHj==d zjsoviB>j^$_^OI_DEPvFkVo(BGRo%cJeD){6Uckei=~1}>sp299|IRjhXe)%?uP0I zF5+>?0#Ye}T^Y$u_rc4=lPcq4K^D(TZG-w30-YiEM=dcK+4#o*>lJ8&JLi+3UcpZk z!^?95S^C0ja^jwP`|{<+3cBVog$(mRdQmadS+Vh~z zS@|P}=|z3P6uS+&@QsMp0no9Od&27O&14zHXGAOEy zh~OKpymK5C%;LLb467@KgIiVwYbYd6wFxI{0-~MOGfTq$nBTB!{SrWmL9Hs}C&l&l#m?s*{tA?BHS4mVKHAVMqm63H<|c5n0~k)-kbg zXidai&9ZUy0~WFYYKT;oe~rytRk?)r8bptITsWj(@HLI;@=v5|XUnSls7$uaxFRL+ zRVMGuL3w}NbV1`^=Pw*0?>bm8+xfeY(1PikW*PB>>Tq(FR`91N0c2&>lL2sZo5=VD zQY{>7dh_TX98L2)n{2OV=T10~*YzX27i2Q7W86M4$?gZIXZaBq#sA*{PH8){|GUi;oM>e?ua7eF4WFuFYZSG| zze?srg|5Ti8Og{O zeFxuw9!U+zhyk?@w zjsA6(oKD=Ka;A>Ca)oPORxK+kxH#O@zhC!!XS4@=swnuMk>t+JmLmFiE^1aX3f<)D@`%K0FGK^gg1a1j>zi z2KhV>sjU7AX3F$SEqrXSC}fRx64GDoc%!u2Yag68Lw@w9v;xOONf@o)Lc|Uh3<21ctTYu-mFZuHk*+R{GjXHIGq3p)tFtQp%TYqD=j1&y)>@zxoxUJ!G@ zgI0XKmP6MNzw>nRxK$-Gbzs}dyfFzt>#5;f6oR27ql!%+{tr+(`(>%51|k`ML} zY4eE)Lxq|JMas(;JibNQds1bUB&r}ydMQXBY4x(^&fY_&LlQC)3hylc$~8&~|06-D z#T+%66rYbHX%^KuqJED_wuGB+=h`nWA!>1n0)3wZrBG3%`b^Ozv6__dNa@%V14|!D zQ?o$z5u0^8`giv%qE!BzZ!3j;BlDlJDk)h@9{nSQeEk!z9RGW) z${RSF3phEM*ce*>Xdp}585vj$|40=&S{S-GTiE?Op*vY&Lvr9}BO$XWy80IF+6@%n z5*2ueT_g@ofP#u5pxb7n*fv^Xtt7&?SRc{*2Ka-*!BuOpf}neHGCiHy$@Ka1^Dint z;DkmIL$-e)rj4o2WQV%Gy;Xg(_Bh#qeOsTM2f@KEe~4kJ8kNLQ+;(!j^bgJMcNhvklP5Z6I+9Fq@c&D~8Fb-4rmDT!MB5QC{Dsb;BharP*O;SF4& zc$wj-7Oep7#$WZN!1nznc@Vb<_Dn%ga-O#J(l=OGB`dy=Sy&$(5-n3zzu%d7E#^8`T@}V+5B;PP8J14#4cCPw-SQTdGa2gWL0*zKM z#DfSXs_iWOMt)0*+Y>Lkd=LlyoHjublNLefhKBv@JoC>P7N1_#> zv=mLWe96%EY;!ZGSQDbZWb#;tzqAGgx~uk+-$+2_8U`!ypbwXl z^2E-FkM1?lY@yt8=J3%QK+xaZ6ok=-y%=KXCD^0r!5vUneW>95PzCkOPO*t}p$;-> ze5j-BLT_;)cZQzR2CEsm@rU7GZfFtdp*a|g4wDr%8?2QkIGasRfDWT-Dvy*U{?IHT z*}wGnzdlSptl#ZF^sf)KT|BJs&kLG91^A6ls{CzFprZ6-Y!V0Xysh%9p%iMd7HLsS zN+^Un$tDV)T@i!v?3o0Fsx2qI(AX_$dDkBzQ@fRM%n zRXk6hb9Py#JXUs+7)w@eo;g%QQ95Yq!K_d=z{0dGS+pToEI6=Bo8+{k$7&Z zo4>PH(`ce8E-Ps&uv`NQ;U$%t;w~|@E3WVOCi~R4oj5wP?%<*1C%}Jq%a^q~T7u>K zML5AKfQDv6>PuT`{SrKHRAF+^&edg6+5R_#H?Lz3iGoWo#PCEd0DS;)2U({{X#zU^ zw_xv{4x7|t!S)>44J;KfA|DC?;uQ($l+5Vp7oeqf7{GBF9356nx|&B~gs+@N^gSdd zvb*>&W)|u#F{Z_b`f#GVtQ`pYv3#||N{xj1NgB<#=Odt6{eB%#9RLt5v zIi|0u70`#ai}9fJjKv7dE!9ZrOIX!3{$z_K5FBd-Kp-&e4(J$LD-)NMTp^_pB`RT; zftVVlK2g@+1Ahv2$D){@Y#cL#dUj9*&%#6 zd2m9{1NYp>)6=oAvqdCn5#cx{AJ%S8skUgMglu2*IAtd+z1>B&`MuEAS(D(<6X#Lj z?f4CFx$)M&$=7*>9v1ER4b6!SIz-m0e{o0BfkySREchp?WdVPpQCh!q$t>?rL!&Jg zd#heM;&~A}VEm8Dvy&P|J*eAV&w!&Nx6HFV&B8jJFVTmgLaswn!cx$&%JbTsloz!3 zMEz1d`k==`Ueub_JAy_&`!ogbwx27^ZXgFNAbx=g_I~5nO^r)}&myw~+yY*cJl4$I znNJ32M&K=0(2Dj_>@39`3=FX!v3nZHno_@q^!y}%(yw0PqOo=);6Y@&ylVe>nMOZ~ zd>j#QQSBn3oaWd;qy$&5(5H$Ayi)0haAYO6TH>FR?rhqHmNOO+(})NB zLI@B@v0)eq!ug`>G<@htRlp3n!EpU|n+G+AvXFrWSUsLMBfL*ZB`CRsIVHNTR&b?K zxBgsN0BjfB>UVcJ|x%=-zb%OV7lmZc& zxiupadZVF7)6QuhoY;;FK2b*qL0J-Rn-8!X4ZY$-ZSUXV5DFd7`T41c(#lAeLMoeT z4%g655v@7AqT!i@)Edt5JMbN(=Q-6{=L4iG8RA%}w;&pKmtWvI4?G9pVRp|RTw`g0 zD5c12B&A2&P6Ng~8WM2eIW=wxd?r7A*N+&!Be7PX3s|7~z=APxm=A?5 zt>xB4WG|*Td@VX{Rs)PV0|yK`oI3^xn(4c_j&vgxk_Y3o(-`_5o`V zRTghg6%l@(qodXN;dB#+OKJEEvhfcnc#BeO2|E(5df-!fKDZ!%9!^BJ_4)9P+9Dq5 zK1=(v?KmIp34r?z{NEWnLB3Px{XYwy-akun4F7xTRr2^zeYW{gcK9)>aJDdU5;w5@ zak=<+-PLH-|04pelTb%ULpuuuJC7DgyT@D|p{!V!0v3KpDnRjANN12q6SUR3mb9<- z>2r~IApQGhstZ!3*?5V z8#)hJ0TdZg0M-BK#nGFP>$i=qk82DO z7h;Ft!D5E15OgW)&%lej*?^1~2=*Z5$2VX>V{x8SC+{i10BbtUk9@I#Vi&hX)q

Q!LwySI{Bnv%Sm)yh{^sSVJ8&h_D-BJ_YZe5eCaAWU9b$O2c z$T|{vWVRtOL!xC0DTc(Qbe`ItNtt5hr<)VijD0{U;T#bUEp381_y`%ZIav?kuYG{iyYdEBPW=*xNSc;Rlt6~F4M`5G+VtOjc z*0qGzCb@gME5udTjJA-9O<&TWd~}ysBd(eVT1-H82-doyH9RST)|+Pb{o*;$j9Tjs zhU!IlsPsj8=(x3bAKJTopW3^6AKROHR^7wZ185wJGVhA~hEc|LP;k7NEz-@4p5o}F z`AD6naG3(n=NF9HTH81=F+Q|JOz$7wm9I<+#BSmB@o_cLt2GkW9|?7mM;r!JZp89l zbo!Hp8=n!XH1{GwaDU+k)pGp`C|cXkCU5%vcH)+v@0eK>%7gWxmuMu9YLlChA|_D@ zi#5zovN_!a-0?~pUV-Rj*1P)KwdU-LguR>YM&*Nen+ln8Q$?WFCJg%DY%K}2!!1FE zDv-A%Cbwo^p(lzac&_TZ-l#9kq`mhLcY3h9ZTUVCM(Ad&=EriQY5{jJv<5K&g|*Lk zgV%ILnf1%8V2B0E&;Sp4sYbYOvvMebLwYwzkRQ#F8GpTQq#uv=J`uaSJ34OWITeSGo6+-8Xw znCk*n{kdDEi)Hi&u^)~cs@iyCkFWB2SWZU|Uc%^43ZIZQ-vWNExCCtDWjqHs;;tWf$v{}0{p0Rvxkq``)*>+Akq%|Na zA`@~-Vfe|+(AIlqru+7Ceh4nsVmO9p9jc8}HX^W&ViBDXT+uXbT#R#idPn&L>+#b6 zflC-4C5-X;kUnR~L>PSLh*gvL68}RBsu#2l`s_9KjUWRhiqF`j)`y`2`YU(>3bdBj z?>iyjEhe-~$^I5!nn%B6Wh+I`FvLNvauve~eX<+Ipl&04 zT}};W&1a3%W?dJ2=N#0t?e+aK+%t}5q%jSLvp3jZ%?&F}nOOWr>+{GFIa%wO_2`et z=JzoRR~}iKuuR+azPI8;Gf9)z3kyA4EIOSl!sRR$DlW}0>&?GbgPojmjmnln;cTqCt=ADbE zZ8GAnoM+S1(5$i8^O4t`ue;vO4i}z0wz-QEIVe5_u03;}-!G1NyY8;h^}y;tzY}i5 zqQr#Ur3Fy8sSa$Q0ys+f`!`+>9WbvU_I`Sj;$4{S>O3?#inLHCrtLy~!s#WXV=oVP zeE93*Nc`PBi4q@%Ao$x4lw9vLHM!6mn3-b_cebF|n-2vt-zYVF_&sDE--J-P;2WHo z+@n2areE0o$LjvjlV2X7ZU@j+`{*8zq`JR3gKF#EW|#+{nMyo-a>nFFTg&vhyT=b} zDa8+v0(Dgx0yRL@ZXOYIlVSZ0|MFizy0VPW8;AfA5|pe!#j zX}Py^8fl5SyS4g1WSKKtnyP+_PoOwMMwu`(i@Z)diJp~U54*-miOchy7Z35eL>^M z4p<-aIxH4VUZgS783@H%M7P9hX>t{|RU7$n4T(brCG#h9e9p! z+o`i;EGGq3&pF;~5V~eBD}lC)>if$w%Vf}AFxGqO88|ApfHf&Bvu+xdG)@vuF}Yvk z)o;~k-%+0K0g+L`Wala!$=ZV|z$e%>f0%XoLib%)!R^RoS+{!#X?h-6uu zF&&KxORdZU&EwQFITIRLo(7TA3W}y6X{?Y%y2j0It!ekU#<)$qghZtpcS>L3uh`Uj z7GY;6f$9qKynP#oS3$$a{p^{D+0oJQ71`1?OAn_m8)UGZmj3l*ZI)`V-a>MKGGFG< z&^jg#Ok%(hhm>hSrZ5;Qga4u(?^i>GiW_j9%_7M>j(^|Om$#{k+^*ULnEgzW_1gCICtAD^WpC`A z{9&DXkG#01Xo)U$OC(L5Y$DQ|Q4C6CjUKk1UkPj$nXH##J{c8e#K|&{mA*;b$r0E4 zUNo0jthwA(c&N1l=PEe8Rw_8cEl|-eya9z&H3#n`B$t#+aJ03RFMzrV@gowbe8v(c zIFM60^0&lCFO10NU4w@|61xiZ4CVXeaKjd;d?sv52XM*lS8XiVjgWpRB;&U_C0g+`6B5V&w|O6B*_q zsATxL!M}+$He)1eOWECce#eS@2n^xhlB4<_Nn?yCVEQWDs(r`|@2GqLe<#(|&P0U? z$7V5IgpWf09uIf_RazRwC?qEqRaHyL?iiS05UiGesJy%^>-C{{ypTBI&B0-iUYhk> zIk<5xpsuV@g|z(AZD+C-;A!fTG=df1=<%nxy(a(IS+U{ME4ZbDEBtcD_3V=icT6*_ z)>|J?>&6%nvHhZERBtjK+s4xnut*@>GAmA5m*OTp$!^CHTr}vM4n(X1Q*;{e-Rd2BCF-u@1ZGm z!S8hJ6L=Gl4T_SDa7Xx|-{4mxveJg=ctf`BJ*fy!yF6Dz&?w(Q_6B}WQVtNI!BVBC zKfX<>7vd6C96}XAQmF-Jd?1Q4eTfRB3q7hCh0f!(JkdWT5<{iAE#dKy*Jxq&3a1@~ z8C||Dn2mFNyrUV|<-)C^_y7@8c2Fz+2jrae9deBDu;U}tJ{^xAdxCD248(k;dCJ%o z`y3sADe>U%suxwwv~8A1+R$VB=Q?%U?4joI$um;aH+eCrBqpn- z%79D_7rb;R-;-9RTrwi9dPlg8&@tfWhhZ(Vx&1PQ+6(huX`;M9x~LrW~~#3{j0Bh2kDU$}@!fFQej4VGkJv?M4rU^x!RU zEwhu$!CA_iDjFjrJa`aocySDX16?~;+wgav;}Zut6Mg%C4>}8FL?8)Kgwc(Qlj{@#2Pt0?G`$h7P#M+qoXtlV@d}%c&OzO+QYKK`kyXaK{U(O^2DyIXCZlNQjt0^8~8JzNGrIxhj}}M z&~QZlbx%t;MJ(Vux;2tgNKGlAqphLq%pd}JG9uoVHUo?|hN{pLQ6Em%r*+7t^<);X zm~6=qChlNAVXNN*Sow->*4;}T;l;D1I-5T{Bif@4_}=>l`tK;qqDdt5zvisCKhMAH z#r}`)7VW?LZqfdmXQ%zo5bJ00{Xb9^YKrk0Nf|oIW*K@(=`o2Vndz}ZDyk{!u}PVx zzd--+_WC*U{~DH3{?GI64IB+@On&@9X>EUAo&L+G{L^dozaI4C3G#2wr~hseW@K&g zKWs{uHu-9Je!3;4pE>eBltKUXb^*hG8I&413)$J&{D4N%7PcloU6bn%jPxJyQL?g* z9g+YFFEDiE`8rW^laCNzQmi7CTnPfwyg3VDHRAl>h=In6jeaVOP@!-CP60j3+#vpL zEYmh_oP0{-gTe7Or`L6x)6w?77QVi~jD8lWN@3RHcm80iV%M1A!+Y6iHM)05iC64tb$X2lV_%Txk@0l^hZqi^%Z?#- zE;LE0uFx)R08_S-#(wC=dS&}vj6P4>5ZWjhthP=*Hht&TdLtKDR;rXEX4*z0h74FA zMCINqrh3Vq;s%3MC1YL`{WjIAPkVL#3rj^9Pj9Ss7>7duy!9H0vYF%>1jh)EPqvlr6h%R%CxDsk| z!BACz7E%j?bm=pH6Eaw{+suniuY7C9Ut~1cWfOX9KW9=H><&kQlinPV3h9R>3nJvK z4L9(DRM=x;R&d#a@oFY7mB|m8h4692U5eYfcw|QKwqRsshN(q^v$4$)HgPpAJDJ`I zkqjq(8Cd!K!+wCd=d@w%~e$=gdUgD&wj$LQ1r>-E=O@c ze+Z$x{>6(JA-fNVr)X;*)40Eym1TtUZI1Pwwx1hUi+G1Jlk~vCYeXMNYtr)1?qwyg zsX_e*$h?380O00ou?0R@7-Fc59o$UvyVs4cUbujHUA>sH!}L54>`e` zHUx#Q+Hn&Og#YVOuo*niy*GU3rH;%f``nk#NN5-xrZ34NeH$l`4@t);4(+0|Z#I>Y z)~Kzs#exIAaf--65L0UHT_SvV8O2WYeD>Mq^Y6L!Xu8%vnpofG@w!}R7M28?i1*T&zp3X4^OMCY6(Dg<-! zXmcGQrRgHXGYre7GfTJ)rhl|rs%abKT_Nt24_Q``XH{88NVPW+`x4ZdrMuO0iZ0g` z%p}y};~T5gbb9SeL8BSc`SO#ixC$@QhXxZ=B}L`tP}&k?1oSPS=4%{UOHe0<_XWln zwbl5cn(j-qK`)vGHY5B5C|QZd5)W7c@{bNVXqJ!!n$^ufc?N9C-BF2QK1(kv++h!>$QbAjq)_b$$PcJdV+F7hz0Hu@ zqj+}m0qn{t^tD3DfBb~0B36|Q`bs*xs|$i^G4uNUEBl4g;op-;Wl~iThgga?+dL7s zUP(8lMO?g{GcYpDS{NM!UA8Hco?#}eNEioRBHy4`mq!Pd-9@-97|k$hpEX>xoX+dY zDr$wfm^P&}Wu{!%?)U_(%Mn79$(ywvu*kJ9r4u|MyYLI_67U7%6Gd_vb##Nerf@>& z8W11z$$~xEZt$dPG}+*IZky+os5Ju2eRi;1=rUEeIn>t-AzC_IGM-IXWK3^6QNU+2pe=MBn4I*R@A%-iLDCOHTE-O^wo$sL_h{dcPl=^muAQb`_BRm};=cy{qSkui;`WSsj9%c^+bIDQ z0`_?KX0<-=o!t{u(Ln)v>%VGL z0pC=GB7*AQ?N7N{ut*a%MH-tdtNmNC+Yf$|KS)BW(gQJ*z$d{+{j?(e&hgTy^2|AR9vx1Xre2fagGv0YXWqtNkg*v%40v?BJBt|f9wX5 z{QTlCM}b-0{mV?IG>TW_BdviUKhtosrBqdfq&Frdz>cF~yK{P@(w{Vr7z2qKFwLhc zQuogKO@~YwyS9%+d-zD7mJG~@?EFJLSn!a&mhE5$_4xBl&6QHMzL?CdzEnC~C3$X@ zvY!{_GR06ep5;<#cKCSJ%srxX=+pn?ywDwtJ2{TV;0DKBO2t++B(tIO4)Wh`rD13P z4fE$#%zkd=UzOB74gi=-*CuID&Z3zI^-`4U^S?dHxK8fP*;fE|a(KYMgMUo`THIS1f!*6dOI2 zFjC3O=-AL`6=9pp;`CYPTdVX z8(*?V&%QoipuH0>WKlL8A*zTKckD!paN@~hh zmXzm~qZhMGVdQGd=AG8&20HW0RGV8X{$9LldFZYm zE?}`Q3i?xJRz43S?VFMmqRyvWaS#(~Lempg9nTM$EFDP(Gzx#$r)W&lpFKqcAoJh-AxEw$-bjW>`_+gEi z2w`99#UbFZGiQjS8kj~@PGqpsPX`T{YOj`CaEqTFag;$jY z8_{Wzz>HXx&G*Dx<5skhpETxIdhKH?DtY@b9l8$l?UkM#J-Snmts7bd7xayKTFJ(u zyAT&@6cAYcs{PBfpqZa%sxhJ5nSZBPji?Zlf&}#L?t)vC4X5VLp%~fz2Sx<*oN<7` z?ge=k<=X7r<~F7Tvp9#HB{!mA!QWBOf%EiSJ6KIF8QZNjg&x~-%e*tflL(ji_S^sO ztmib1rp09uon}RcsFi#k)oLs@$?vs(i>5k3YN%$T(5Or(TZ5JW9mA6mIMD08=749$ z!d+l*iu{Il7^Yu}H;lgw=En1sJpCKPSqTCHy4(f&NPelr31^*l%KHq^QE>z>Ks_bH zjbD?({~8Din7IvZeJ>8Ey=e;I?thpzD=zE5UHeO|neioJwG;IyLk?xOz(yO&0DTU~ z^#)xcs|s>Flgmp;SmYJ4g(|HMu3v7#;c*Aa8iF#UZo7CvDq4>8#qLJ|YdZ!AsH%^_7N1IQjCro

K7UpUK$>l@ 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 E2O(~oYXATM literal 0 HcmV?d00001 diff --git a/depth_estimation/gradle/wrapper/gradle-wrapper.properties b/depth_estimation/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..2a4f313 --- /dev/null +++ b/depth_estimation/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Wed Aug 25 07:50:30 IST 2021 +distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip +distributionPath=wrapper/dists +zipStorePath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME diff --git a/depth_estimation/gradlew b/depth_estimation/gradlew new file mode 100644 index 0000000..4f906e0 --- /dev/null +++ b/depth_estimation/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# 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 +# +# https://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. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/depth_estimation/gradlew.bat b/depth_estimation/gradlew.bat new file mode 100644 index 0000000..ac1b06f --- /dev/null +++ b/depth_estimation/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/depth_estimation/repo_images/depth_sample.jpg b/depth_estimation/repo_images/depth_sample.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1df12c587434483d4cc3367582c00d48af07621a GIT binary patch literal 21138 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 E*{O>@k^lez literal 0 HcmV?d00001 diff --git a/depth_estimation/repo_images/rgb_sample.jpg b/depth_estimation/repo_images/rgb_sample.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a68868cff4f3e72643526d31e97690aa3a31ad0b GIT binary patch literal 50387 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 Date: Sat, 2 Oct 2021 11:11:41 +0530 Subject: [PATCH 2/6] Made proposed changes --- README.md | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 6a15075..d258463 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,13 @@ So if you like to see the kotlin, you can go through the repo! ## Example apps +### Depth Estimation + +An Android app which uses the MiDaS model to perform monocular depth estimation on RGB images directly. The app displays a depth map over the live camera feed and works for both the front and the rear cameras. + + +Contributed from: https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android + ### Digit classifier *End-to-end sample of a digit classifier model built with TensorFlow 2.0 (Keras API), and trained on MNIST dataset.* @@ -46,14 +53,6 @@ Artistic style transfer is an optimization technique used to take two images: a Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Depth Estimation - -Perform realtime depth estimation using the MiDaS model available on [TensorFlow Hub](https://tfhub.dev/intel/midas/v2_1_small/1). This project is added from [shubham0204 -/ -Realtime_MiDaS_Depth_Estimation_Android](https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android). Refer to the [README](https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android/blob/master/README.md) for all the details. - -Added from: https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android - ### Coming Soon! πŸš€ From da70c0af30b0cae558ce61e5993ec6d6ffe7b197 Mon Sep 17 00:00:00 2001 From: shubham0204 Date: Sat, 2 Oct 2021 11:17:50 +0530 Subject: [PATCH 3/6] Fixed README typos and titles --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index d258463..9229dd9 100644 --- a/README.md +++ b/README.md @@ -14,33 +14,33 @@ An Android app which uses the MiDaS model to perform monocular depth estimation Contributed from: https://github.com/shubham0204/Realtime_MiDaS_Depth_Estimation_Android -### Digit classifier +### Digit Classifier *End-to-end sample of a digit classifier model built with TensorFlow 2.0 (Keras API), and trained on MNIST dataset.* Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Image segmentaion +### Image Segmentation The used model, [DeepLab](https://ai.googleblog.com/2018/03/semantic-image-segmentation-with.html) is a state-of-art deep learning model for semantic image segmentation, where the goal is to assign semantic labels (e.g. person, dog, cat) to every pixel in the input image. Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Optical character recognition +### Optical Character Recognition OCR is the process of recognizing characters from images using computer vision and machine learning techniques. This reference app demos how to use TensorFlow Lite to do OCR. It uses a text detection model and a text recognition model as a pipeline to recognize texts. Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Pose esimation +### Pose Estimation This is an app that continuously detects the body parts in the frames seen by your device's camera. These instructions walk you through building and running the demo on an Android device. Camera captures are discarded immediately after use, nothing is stored or saved. Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Pose net +### PoseNet This is an app that continuously detects the body parts in the frames seen by your device's camera. These instructions walk you through building and running the demo on an Android device. Camera captures are discarded immediately after use, nothing is stored or saved. Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Sound classification +### Sound Classification This Android application demonstrates how to classify sound on-device. It uses: - TFLite Task Library @@ -48,15 +48,15 @@ This Android application demonstrates how to classify sound on-device. It uses: Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Style transfer +### Style Transfer Artistic style transfer is an optimization technique used to take two images: a content image and a style reference image (such as an artwork by a famous painter) and blend them together so the output image looks like the content image, but β€œpainted” in the style of the style reference image. Added from: https://github.com/tensorflow/examples/tree/master/lite/examples -### Coming Soon! πŸš€ +## Coming Soon! πŸš€ -**BERT qa** +**BERT Q&A** **Text classification** @@ -84,5 +84,5 @@ Added from: https://github.com/tensorflow/examples/tree/master/lite/examples - [ ] Designing & Creating example apps with the [Interpreter](https://www.tensorflow.org/lite/inference_with_metadata/lite_support), to show the implementation. - [ ] Maintaining the Apps - ## Contribute ❀️ +## Contribute ❀️ You can just create new a [new issue](https://github.com/SunitRoy2703/Tensorflow-lite-samples-kotlin/issues/new), mail me at iamsunitroy03@gmail.com \ No newline at end of file From b407bc1462b9608a6725c70fd58da667cb8eec7c Mon Sep 17 00:00:00 2001 From: shubham0204 Date: Thu, 7 Oct 2021 12:45:03 +0530 Subject: [PATCH 4/6] Removed NNApiDelegate --- depth_estimation/.gitignore | 19 +++++++++++++++++++ .../ml/depthestimation/MiDASModel.kt | 6 ------ 2 files changed, 19 insertions(+), 6 deletions(-) create mode 100644 depth_estimation/.gitignore diff --git a/depth_estimation/.gitignore b/depth_estimation/.gitignore new file mode 100644 index 0000000..36cd7f3 --- /dev/null +++ b/depth_estimation/.gitignore @@ -0,0 +1,19 @@ +*.iml +.gradle +/local.properties +/.idea +/.gradle +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.propertie +/app/src/androidTest +/app/src/test diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt index b556545..d6ccdc7 100644 --- a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt @@ -75,12 +75,6 @@ class MiDASModel( context: Context ) { // Number of threads for computation setNumThreads( NUM_THREADS ) } - // Add the NNApiDelegate if supported. - // See -> https://www.tensorflow.org/lite/performance/nnapi#initializing_the_nnapi_delegate - if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.P ) { - Logger.logInfo( "NNAPI is supported on this device." ) - addDelegate( NnApiDelegate() ) - } } interpreter = Interpreter(FileUtil.loadMappedFile( context, modelFileName ) , interpreterOptions ) Logger.logInfo( "TFLite interpreter created." ) From a06b941d6e1e7fc8e0e31d9d1f67ca627886b7ec Mon Sep 17 00:00:00 2001 From: shubham0204 Date: Thu, 7 Oct 2021 13:11:09 +0530 Subject: [PATCH 5/6] Added download.gradle file --- depth_estimation/.gitignore | 7 +++---- depth_estimation/app/build.gradle | 7 +++++++ depth_estimation/app/download.gradle | 10 ++++++++++ .../com/shubham0204/ml/depthestimation/MiDASModel.kt | 6 ++++++ depth_estimation/build.gradle | 1 + 5 files changed, 27 insertions(+), 4 deletions(-) create mode 100644 depth_estimation/app/download.gradle diff --git a/depth_estimation/.gitignore b/depth_estimation/.gitignore index 36cd7f3..0c05a4c 100644 --- a/depth_estimation/.gitignore +++ b/depth_estimation/.gitignore @@ -2,7 +2,8 @@ .gradle /local.properties /.idea -/.gradle +/app/src/androidTest +/app/src/test /.idea/caches /.idea/libraries /.idea/modules.xml @@ -14,6 +15,4 @@ /captures .externalNativeBuild .cxx -local.propertie -/app/src/androidTest -/app/src/test +local.properties diff --git a/depth_estimation/app/build.gradle b/depth_estimation/app/build.gradle index 143c7c3..fa479eb 100644 --- a/depth_estimation/app/build.gradle +++ b/depth_estimation/app/build.gradle @@ -33,6 +33,13 @@ android { } } +// App assets folder +project.ext.ASSET_DIR = projectDir.toString() + '/src/main/assets' + +// Download TF Lite model. +apply from: 'download.gradle' + + dependencies { implementation 'androidx.core:core-ktx:1.6.0' implementation 'androidx.appcompat:appcompat:1.3.1' diff --git a/depth_estimation/app/download.gradle b/depth_estimation/app/download.gradle new file mode 100644 index 0000000..f40efe8 --- /dev/null +++ b/depth_estimation/app/download.gradle @@ -0,0 +1,10 @@ +apply plugin: 'de.undercouch.download' + +task downloadModelFile(type: Download) { + src 'https://tfhub.dev/intel/lite-model/midas/v2_1_small/1/lite/1?lite-format=tflite' + dest project.ext.ASSET_DIR + '/depth_model.tflite' + overwrite false +} + + +preBuild.dependsOn downloadModelFile \ No newline at end of file diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt index d6ccdc7..b556545 100644 --- a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt @@ -75,6 +75,12 @@ class MiDASModel( context: Context ) { // Number of threads for computation setNumThreads( NUM_THREADS ) } + // Add the NNApiDelegate if supported. + // See -> https://www.tensorflow.org/lite/performance/nnapi#initializing_the_nnapi_delegate + if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.P ) { + Logger.logInfo( "NNAPI is supported on this device." ) + addDelegate( NnApiDelegate() ) + } } interpreter = Interpreter(FileUtil.loadMappedFile( context, modelFileName ) , interpreterOptions ) Logger.logInfo( "TFLite interpreter created." ) diff --git a/depth_estimation/build.gradle b/depth_estimation/build.gradle index fee67c2..486cbf4 100644 --- a/depth_estimation/build.gradle +++ b/depth_estimation/build.gradle @@ -7,6 +7,7 @@ buildscript { dependencies { classpath "com.android.tools.build:gradle:7.0.0" classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20" + classpath 'de.undercouch:gradle-download-task:4.0.2' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files From d3c114ad226a5ad215a93b123bc7b7fe6da7da39 Mon Sep 17 00:00:00 2001 From: Sunit Roy Date: Thu, 7 Oct 2021 18:13:35 +0530 Subject: [PATCH 6/6] Removed NNApiDelegate check --- .../com/shubham0204/ml/depthestimation/MiDASModel.kt | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt index b556545..09e9f97 100644 --- a/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt +++ b/depth_estimation/app/src/main/java/com/shubham0204/ml/depthestimation/MiDASModel.kt @@ -75,13 +75,7 @@ class MiDASModel( context: Context ) { // Number of threads for computation setNumThreads( NUM_THREADS ) } - // Add the NNApiDelegate if supported. - // See -> https://www.tensorflow.org/lite/performance/nnapi#initializing_the_nnapi_delegate - if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.P ) { - Logger.logInfo( "NNAPI is supported on this device." ) - addDelegate( NnApiDelegate() ) - } - } + interpreter = Interpreter(FileUtil.loadMappedFile( context, modelFileName ) , interpreterOptions ) Logger.logInfo( "TFLite interpreter created." ) } @@ -146,6 +140,4 @@ class MiDASModel( context: Context ) { } - - -} \ No newline at end of file +}