← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java
 
1
package org.opencv.samples.imagemanipulations;
 
2
 
 
3
import java.util.Arrays;
 
4
 
 
5
import org.opencv.android.BaseLoaderCallback;
 
6
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
 
7
import org.opencv.android.LoaderCallbackInterface;
 
8
import org.opencv.android.OpenCVLoader;
 
9
import org.opencv.core.Core;
 
10
import org.opencv.core.CvType;
 
11
import org.opencv.core.Mat;
 
12
import org.opencv.core.MatOfFloat;
 
13
import org.opencv.core.MatOfInt;
 
14
import org.opencv.core.Point;
 
15
import org.opencv.core.Scalar;
 
16
import org.opencv.core.Size;
 
17
import org.opencv.android.CameraBridgeViewBase;
 
18
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
 
19
import org.opencv.imgproc.Imgproc;
 
20
 
 
21
import android.app.Activity;
 
22
import android.os.Bundle;
 
23
import android.util.Log;
 
24
import android.view.Menu;
 
25
import android.view.MenuItem;
 
26
import android.view.WindowManager;
 
27
 
 
28
public class ImageManipulationsActivity extends Activity implements CvCameraViewListener2 {
 
29
    private static final String  TAG                 = "OCVSample::Activity";
 
30
 
 
31
    public static final int      VIEW_MODE_RGBA      = 0;
 
32
    public static final int      VIEW_MODE_HIST      = 1;
 
33
    public static final int      VIEW_MODE_CANNY     = 2;
 
34
    public static final int      VIEW_MODE_SEPIA     = 3;
 
35
    public static final int      VIEW_MODE_SOBEL     = 4;
 
36
    public static final int      VIEW_MODE_ZOOM      = 5;
 
37
    public static final int      VIEW_MODE_PIXELIZE  = 6;
 
38
    public static final int      VIEW_MODE_POSTERIZE = 7;
 
39
 
 
40
    private MenuItem             mItemPreviewRGBA;
 
41
    private MenuItem             mItemPreviewHist;
 
42
    private MenuItem             mItemPreviewCanny;
 
43
    private MenuItem             mItemPreviewSepia;
 
44
    private MenuItem             mItemPreviewSobel;
 
45
    private MenuItem             mItemPreviewZoom;
 
46
    private MenuItem             mItemPreviewPixelize;
 
47
    private MenuItem             mItemPreviewPosterize;
 
48
    private CameraBridgeViewBase mOpenCvCameraView;
 
49
 
 
50
    private Size                 mSize0;
 
51
 
 
52
    private Mat                  mIntermediateMat;
 
53
    private Mat                  mMat0;
 
54
    private MatOfInt             mChannels[];
 
55
    private MatOfInt             mHistSize;
 
56
    private int                  mHistSizeNum = 25;
 
57
    private MatOfFloat           mRanges;
 
58
    private Scalar               mColorsRGB[];
 
59
    private Scalar               mColorsHue[];
 
60
    private Scalar               mWhilte;
 
61
    private Point                mP1;
 
62
    private Point                mP2;
 
63
    private float                mBuff[];
 
64
    private Mat                  mSepiaKernel;
 
65
 
 
66
    public static int           viewMode = VIEW_MODE_RGBA;
 
67
 
 
68
    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
 
69
        @Override
 
70
        public void onManagerConnected(int status) {
 
71
            switch (status) {
 
72
                case LoaderCallbackInterface.SUCCESS:
 
73
                {
 
74
                    Log.i(TAG, "OpenCV loaded successfully");
 
75
                    mOpenCvCameraView.enableView();
 
76
                } break;
 
77
                default:
 
78
                {
 
79
                    super.onManagerConnected(status);
 
80
                } break;
 
81
            }
 
82
        }
 
83
    };
 
84
 
 
85
    public ImageManipulationsActivity() {
 
86
        Log.i(TAG, "Instantiated new " + this.getClass());
 
87
    }
 
88
 
 
89
    /** Called when the activity is first created. */
 
90
    @Override
 
91
    public void onCreate(Bundle savedInstanceState) {
 
92
        Log.i(TAG, "called onCreate");
 
93
        super.onCreate(savedInstanceState);
 
94
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 
95
 
 
96
        setContentView(R.layout.image_manipulations_surface_view);
 
97
 
 
98
        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.image_manipulations_activity_surface_view);
 
99
        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
 
100
        mOpenCvCameraView.setCvCameraViewListener(this);
 
101
    }
 
102
 
 
103
    @Override
 
104
    public void onPause()
 
105
    {
 
106
        super.onPause();
 
107
        if (mOpenCvCameraView != null)
 
108
            mOpenCvCameraView.disableView();
 
109
    }
 
110
 
 
111
    @Override
 
112
    public void onResume()
 
113
    {
 
114
        super.onResume();
 
115
        if (!OpenCVLoader.initDebug()) {
 
116
            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
 
117
            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
 
118
        } else {
 
119
            Log.d(TAG, "OpenCV library found inside package. Using it!");
 
120
            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
 
121
        }
 
122
    }
 
123
 
 
124
    public void onDestroy() {
 
125
        super.onDestroy();
 
126
        if (mOpenCvCameraView != null)
 
127
            mOpenCvCameraView.disableView();
 
128
    }
 
129
 
 
130
    @Override
 
131
    public boolean onCreateOptionsMenu(Menu menu) {
 
132
        Log.i(TAG, "called onCreateOptionsMenu");
 
133
        mItemPreviewRGBA  = menu.add("Preview RGBA");
 
134
        mItemPreviewHist  = menu.add("Histograms");
 
135
        mItemPreviewCanny = menu.add("Canny");
 
136
        mItemPreviewSepia = menu.add("Sepia");
 
137
        mItemPreviewSobel = menu.add("Sobel");
 
138
        mItemPreviewZoom  = menu.add("Zoom");
 
139
        mItemPreviewPixelize  = menu.add("Pixelize");
 
140
        mItemPreviewPosterize = menu.add("Posterize");
 
141
        return true;
 
142
    }
 
143
 
 
144
    @Override
 
145
    public boolean onOptionsItemSelected(MenuItem item) {
 
146
        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
 
147
        if (item == mItemPreviewRGBA)
 
148
            viewMode = VIEW_MODE_RGBA;
 
149
        if (item == mItemPreviewHist)
 
150
            viewMode = VIEW_MODE_HIST;
 
151
        else if (item == mItemPreviewCanny)
 
152
            viewMode = VIEW_MODE_CANNY;
 
153
        else if (item == mItemPreviewSepia)
 
154
            viewMode = VIEW_MODE_SEPIA;
 
155
        else if (item == mItemPreviewSobel)
 
156
            viewMode = VIEW_MODE_SOBEL;
 
157
        else if (item == mItemPreviewZoom)
 
158
            viewMode = VIEW_MODE_ZOOM;
 
159
        else if (item == mItemPreviewPixelize)
 
160
            viewMode = VIEW_MODE_PIXELIZE;
 
161
        else if (item == mItemPreviewPosterize)
 
162
            viewMode = VIEW_MODE_POSTERIZE;
 
163
        return true;
 
164
    }
 
165
 
 
166
    public void onCameraViewStarted(int width, int height) {
 
167
        mIntermediateMat = new Mat();
 
168
        mSize0 = new Size();
 
169
        mChannels = new MatOfInt[] { new MatOfInt(0), new MatOfInt(1), new MatOfInt(2) };
 
170
        mBuff = new float[mHistSizeNum];
 
171
        mHistSize = new MatOfInt(mHistSizeNum);
 
172
        mRanges = new MatOfFloat(0f, 256f);
 
173
        mMat0  = new Mat();
 
174
        mColorsRGB = new Scalar[] { new Scalar(200, 0, 0, 255), new Scalar(0, 200, 0, 255), new Scalar(0, 0, 200, 255) };
 
175
        mColorsHue = new Scalar[] {
 
176
                new Scalar(255, 0, 0, 255),   new Scalar(255, 60, 0, 255),  new Scalar(255, 120, 0, 255), new Scalar(255, 180, 0, 255), new Scalar(255, 240, 0, 255),
 
177
                new Scalar(215, 213, 0, 255), new Scalar(150, 255, 0, 255), new Scalar(85, 255, 0, 255),  new Scalar(20, 255, 0, 255),  new Scalar(0, 255, 30, 255),
 
178
                new Scalar(0, 255, 85, 255),  new Scalar(0, 255, 150, 255), new Scalar(0, 255, 215, 255), new Scalar(0, 234, 255, 255), new Scalar(0, 170, 255, 255),
 
179
                new Scalar(0, 120, 255, 255), new Scalar(0, 60, 255, 255),  new Scalar(0, 0, 255, 255),   new Scalar(64, 0, 255, 255),  new Scalar(120, 0, 255, 255),
 
180
                new Scalar(180, 0, 255, 255), new Scalar(255, 0, 255, 255), new Scalar(255, 0, 215, 255), new Scalar(255, 0, 85, 255),  new Scalar(255, 0, 0, 255)
 
181
        };
 
182
        mWhilte = Scalar.all(255);
 
183
        mP1 = new Point();
 
184
        mP2 = new Point();
 
185
 
 
186
        // Fill sepia kernel
 
187
        mSepiaKernel = new Mat(4, 4, CvType.CV_32F);
 
188
        mSepiaKernel.put(0, 0, /* R */0.189f, 0.769f, 0.393f, 0f);
 
189
        mSepiaKernel.put(1, 0, /* G */0.168f, 0.686f, 0.349f, 0f);
 
190
        mSepiaKernel.put(2, 0, /* B */0.131f, 0.534f, 0.272f, 0f);
 
191
        mSepiaKernel.put(3, 0, /* A */0.000f, 0.000f, 0.000f, 1f);
 
192
    }
 
193
 
 
194
    public void onCameraViewStopped() {
 
195
        // Explicitly deallocate Mats
 
196
        if (mIntermediateMat != null)
 
197
            mIntermediateMat.release();
 
198
 
 
199
        mIntermediateMat = null;
 
200
    }
 
201
 
 
202
    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
 
203
        Mat rgba = inputFrame.rgba();
 
204
        Size sizeRgba = rgba.size();
 
205
 
 
206
        Mat rgbaInnerWindow;
 
207
 
 
208
        int rows = (int) sizeRgba.height;
 
209
        int cols = (int) sizeRgba.width;
 
210
 
 
211
        int left = cols / 8;
 
212
        int top = rows / 8;
 
213
 
 
214
        int width = cols * 3 / 4;
 
215
        int height = rows * 3 / 4;
 
216
 
 
217
        switch (ImageManipulationsActivity.viewMode) {
 
218
        case ImageManipulationsActivity.VIEW_MODE_RGBA:
 
219
            break;
 
220
 
 
221
        case ImageManipulationsActivity.VIEW_MODE_HIST:
 
222
            Mat hist = new Mat();
 
223
            int thikness = (int) (sizeRgba.width / (mHistSizeNum + 10) / 5);
 
224
            if(thikness > 5) thikness = 5;
 
225
            int offset = (int) ((sizeRgba.width - (5*mHistSizeNum + 4*10)*thikness)/2);
 
226
            // RGB
 
227
            for(int c=0; c<3; c++) {
 
228
                Imgproc.calcHist(Arrays.asList(rgba), mChannels[c], mMat0, hist, mHistSize, mRanges);
 
229
                Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
 
230
                hist.get(0, 0, mBuff);
 
231
                for(int h=0; h<mHistSizeNum; h++) {
 
232
                    mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
 
233
                    mP1.y = sizeRgba.height-1;
 
234
                    mP2.y = mP1.y - 2 - (int)mBuff[h];
 
235
                    Imgproc.line(rgba, mP1, mP2, mColorsRGB[c], thikness);
 
236
                }
 
237
            }
 
238
            // Value and Hue
 
239
            Imgproc.cvtColor(rgba, mIntermediateMat, Imgproc.COLOR_RGB2HSV_FULL);
 
240
            // Value
 
241
            Imgproc.calcHist(Arrays.asList(mIntermediateMat), mChannels[2], mMat0, hist, mHistSize, mRanges);
 
242
            Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
 
243
            hist.get(0, 0, mBuff);
 
244
            for(int h=0; h<mHistSizeNum; h++) {
 
245
                mP1.x = mP2.x = offset + (3 * (mHistSizeNum + 10) + h) * thikness;
 
246
                mP1.y = sizeRgba.height-1;
 
247
                mP2.y = mP1.y - 2 - (int)mBuff[h];
 
248
                Imgproc.line(rgba, mP1, mP2, mWhilte, thikness);
 
249
            }
 
250
            // Hue
 
251
            Imgproc.calcHist(Arrays.asList(mIntermediateMat), mChannels[0], mMat0, hist, mHistSize, mRanges);
 
252
            Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
 
253
            hist.get(0, 0, mBuff);
 
254
            for(int h=0; h<mHistSizeNum; h++) {
 
255
                mP1.x = mP2.x = offset + (4 * (mHistSizeNum + 10) + h) * thikness;
 
256
                mP1.y = sizeRgba.height-1;
 
257
                mP2.y = mP1.y - 2 - (int)mBuff[h];
 
258
                Imgproc.line(rgba, mP1, mP2, mColorsHue[h], thikness);
 
259
            }
 
260
            break;
 
261
 
 
262
        case ImageManipulationsActivity.VIEW_MODE_CANNY:
 
263
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
 
264
            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
 
265
            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
 
266
            rgbaInnerWindow.release();
 
267
            break;
 
268
 
 
269
        case ImageManipulationsActivity.VIEW_MODE_SOBEL:
 
270
            Mat gray = inputFrame.gray();
 
271
            Mat grayInnerWindow = gray.submat(top, top + height, left, left + width);
 
272
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
 
273
            Imgproc.Sobel(grayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1);
 
274
            Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
 
275
            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
 
276
            grayInnerWindow.release();
 
277
            rgbaInnerWindow.release();
 
278
            break;
 
279
 
 
280
        case ImageManipulationsActivity.VIEW_MODE_SEPIA:
 
281
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
 
282
            Core.transform(rgbaInnerWindow, rgbaInnerWindow, mSepiaKernel);
 
283
            rgbaInnerWindow.release();
 
284
            break;
 
285
 
 
286
        case ImageManipulationsActivity.VIEW_MODE_ZOOM:
 
287
            Mat zoomCorner = rgba.submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);
 
288
            Mat mZoomWindow = rgba.submat(rows / 2 - 9 * rows / 100, rows / 2 + 9 * rows / 100, cols / 2 - 9 * cols / 100, cols / 2 + 9 * cols / 100);
 
289
            Imgproc.resize(mZoomWindow, zoomCorner, zoomCorner.size());
 
290
            Size wsize = mZoomWindow.size();
 
291
            Imgproc.rectangle(mZoomWindow, new Point(1, 1), new Point(wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0, 255), 2);
 
292
            zoomCorner.release();
 
293
            mZoomWindow.release();
 
294
            break;
 
295
 
 
296
        case ImageManipulationsActivity.VIEW_MODE_PIXELIZE:
 
297
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
 
298
            Imgproc.resize(rgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.INTER_NEAREST);
 
299
            Imgproc.resize(mIntermediateMat, rgbaInnerWindow, rgbaInnerWindow.size(), 0., 0., Imgproc.INTER_NEAREST);
 
300
            rgbaInnerWindow.release();
 
301
            break;
 
302
 
 
303
        case ImageManipulationsActivity.VIEW_MODE_POSTERIZE:
 
304
            /*
 
305
            Imgproc.cvtColor(rgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB);
 
306
            Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50);
 
307
            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_RGB2RGBA);
 
308
            */
 
309
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
 
310
            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
 
311
            rgbaInnerWindow.setTo(new Scalar(0, 0, 0, 255), mIntermediateMat);
 
312
            Core.convertScaleAbs(rgbaInnerWindow, mIntermediateMat, 1./16, 0);
 
313
            Core.convertScaleAbs(mIntermediateMat, rgbaInnerWindow, 16, 0);
 
314
            rgbaInnerWindow.release();
 
315
            break;
 
316
        }
 
317
 
 
318
        return rgba;
 
319
    }
 
320
}