Розробка алгоритму виявлення перешкод в просторі та його реалізація на сучасній мобільній платформі Android

3. Tina Yu Tian, Mubarak Shah, "Recovering 3D Motion of Multiple Objects Using Adaptive Hough Transform" IEEE Trans. Pattern Anal. Mach. Intell. 19(10): 1178-1183 (1997)

4. A.B.J. Kuijlaars Which eigenvalues are found by the Lanczos method?/ A. B. J. Kuijlaars // SIAM J. Matrix Anal. Appl. -2000. - №22. - p. 306-321.

5. A.B.J. Kuijlaars Convergence analysis of Krylov subspace iterations with methods from potential theory/ A.B.J. Kuijlaars // SIAM Rev. - 2006. - №48. - p. 3-40.

6. Yousef Saad Iterative Methods for Sparse Linear Systems / Y. Saad // SIAM Rev. - 2006. - №2. - p.373-547.

7. A. Ruhe Rational Krylov sequence methods for eigenvalue computation / A. Ruhe // Linear Algebra Appl. -1984. - №58. - p. 391-405.

8. B. Simon CMV matrices: Five years after / B. Simon // J. Comput. Appl. Math. - 2007. - №208. - p. 120-154.

9. T. Mach Computing approximate extended Krylov subspaces without explicit inversions / T. Mach, M. S. Pranic, R. Vandebril // ETNA Rev. - 2013. - №40. - p. 414-435.

10. R. Vandebril Chasing bulges or rotations? A metamorphosis of the QR-algorithm / R. Vandebril // SIAM J. Matrix Anal. Appl. - 2011. - №32. - p. 217-247.

11. R. Vandebril A generalization of the multishift QR algorithm / R. Vandebril, D.S. Watkins // SIAM J. Matrix Anal. Appl. - 2012. - №33. - p. 759-779.

12. Розміри єдиного внеску на соціальне страхування відповідно до класів професійного ризику виробництва [Електронний ресурс]

13. Тарифи на електричну енергію (крім населення) [Електронний ресурс] : постанова [видано кабінетом міністрів України від 15.08.2005 №745]



ДОДАТОК А

Ілюстративний матеріал доповіді



ДОДАТОК Б

Код програмного продукту

package org.opencv.samples.tutorial2;

import android.content.Context;

import android.hardware.SensorListener;

import android.hardware.SensorManager;

import android.util.Log;

public class SensorsManager implements android.hardware.SensorListener {

public interface SensorListener {

public void onData(double a, double b, double c);

}

private static String TAG = SensorsManager.class.getSimpleName();

private static SensorsManager mInstance;

private SensorManager sensorManager;

private static int sensor = SensorManager.SENSOR_ORIENTATION;

private SensorListener listener;

public static SensorsManager init(Context ctx) {

if (mInstance == null)

mInstance = new SensorsManager(ctx);

else

Log.w(TAG, "Second init!");

return mInstance;

}

public static void setListener(SensorListener listener) {

mInstance.listener = listener;

}

private SensorsManager(Context ctx) {

sensorManager = (SensorManager)

ctx.getSystemService(Context.SENSOR_SERVICE);

}

public static void start() {

mInstance.sensorManager.registerListener(mInstance, sensor);

}

public static void stop() {

mInstance.sensorManager.unregisterListener(mInstance, sensor);

}

public void onAccuracyChanged(int sensor, int accuracy) {

Log.d(TAG, String.format("onAccuracyChanged sensor: %d accuraccy:

%d",

sensor, accuracy));

}

public void onSensorChanged(int sensorReporting, float[] values) {

if (sensorReporting != sensor)

return;

float azimuth = (values[0]);

double pitch = (values[1]);

float roll = (values[2]);

double distance = 1.5*Math.tan(Math.toRadians(-pitch));

if (listener != null)

listener.onData(azimuth, pitch, roll);

}

}

package org.opencv.samples.tutorial2;

import java.io.FileOutputStream;

import java.util.List;

import org.opencv.android.JavaCameraView;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.hardware.Camera;

import android.hardware.Camera.PictureCallback;

import android.hardware.Camera.Size;

import android.util.AttributeSet;

import android.util.Log;

public class Tutorial3View extends JavaCameraView {

private static final String TAG = "Sample::Tutorial3View";

public Tutorial3View(Context context, AttributeSet attrs) {

super(context, attrs);

}

public List<String> getEffectList() {

return mCamera.getParameters().getSupportedColorEffects();

}

public boolean isEffectSupported() {

return (mCamera.getParameters().getColorEffect() != null);

}

public String getEffect() {

return mCamera.getParameters().getColorEffect();

}

public void setEffect(String effect) {

Camera.Parameters params = mCamera.getParameters();

params.setColorEffect(effect);

mCamera.setParameters(params);

}

public List<Size> getResolutionList() {

return mCamera.getParameters().getSupportedPreviewSizes();

}

public void setResolution(Size resolution) {

disconnectCamera();

mMaxHeight = resolution.height;

mMaxWidth = resolution.width;

connectCamera(getWidth(), getHeight());

}

public Size getResolution() {

return mCamera.getParameters().getPreviewSize();

}

public void takePicture(final String fileName) {

Log.i(TAG, "Tacking picture");

PictureCallback callback = new PictureCallback() {

private String mPictureFileName = fileName;

@Override

public void onPictureTaken(byte[] data, Camera camera) {

Log.i(TAG, "Saving a bitmap to file");

Bitmap picture = BitmapFactory.decodeByteArray(data, 0, data.length);

try {

FileOutputStream out = new FileOutputStream(mPictureFileName);

picture.compress(Bitmap.CompressFormat.JPEG, 90, out);

picture.recycle();

mCamera.startPreview();

} catch (Exception e) {

e.printStackTrace();

}

}

};

mCamera.takePicture(null, null, callback);

}

public double getHorizontalAngle() {

return mCamera.getParameters().getHorizontalViewAngle();

}

public double getVerticalAngle() {

return mCamera.getParameters().getVerticalViewAngle();

}

}

package org.opencv.samples.tutorial2;

import org.opencv.android.BaseLoaderCallback;

import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;

import org.opencv.android.LoaderCallbackInterface;

import org.opencv.android.OpenCVLoader;

import org.opencv.core.CvType;

import org.opencv.core.Mat;

import org.opencv.android.CameraBridgeViewBase;

import

org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;

import org.opencv.imgproc.Imgproc;

import org.opencv.android.JavaCameraView;

import android.app.Activity;

import android.os.Bundle;

import android.util.Log;

import java.util.List;

import android.view.Menu;

import android.view.MenuItem;

import android.view.WindowManager;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.hardware.Camera;

import android.hardware.Camera.PictureCallback;

import android.hardware.Camera.Size;

import android.util.AttributeSet;

public class Tutorial2Activity extends Activity implements

CvCameraViewListener2 {

private static final String TAG = "OCVSample::Activity";

private static final int VIEW_MODE_RGBA = 0;

private static final int VIEW_MODE_GRAY = 1;

private static final int VIEW_MODE_CANNY = 2;

private static final int VIEW_MODE_FEATURES = 5;

private int mViewMode;

private Mat mRgba;

private Mat mIntermediateMat;

private Mat mGray;

private MenuItem mItemPreviewRGBA;

private MenuItem mItemPreviewGray;

private MenuItem mItemPreviewCanny;

private MenuItem mItemPreviewFeatures;

private Tutorial3View mOpenCvCameraView;

double ha, hb;

double sa,sb,sc;

private BaseLoaderCallback mLoaderCallback = new

BaseLoaderCallback(this) {

@Override

public void onManagerConnected(int status) {

switch (status) {

case LoaderCallbackInterface.SUCCESS:

{

Log.i(TAG, "OpenCV loaded successfully");

// Load native library after(!) OpenCV initialization

System.loadLibrary("mixed_sample");

mOpenCvCameraView.enableView();

} break;

default:

{

super.onManagerConnected(status);

} break;

}

}

};

private SensorsManager.SensorListener sensorListener = new

SensorsManager.SensorListener() {

@Override

public void onData(double a, double b, double c) {

sa=a;

sb=b;

sc=c;

}

};

public Tutorial2Activity() {

Log.i(TAG, "Instantiated new " + this.getClass());

}

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

Log.i(TAG, "called onCreate");

super.onCreate(savedInstanceState);

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCR

EEN_ON);

setContentView(R.layout.tutorial2_surface_view);

mOpenCvCameraView = (Tutorial3View)

findViewById(R.id.tutorial2_activity_surface_view);

mOpenCvCameraView.setCvCameraViewListener(this);

SensorsManager.init(this);

SensorsManager.setListener(sensorListener);

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

Log.i(TAG, "called onCreateOptionsMenu");

mItemPreviewRGBA = menu.add("Preview RGBA");

mItemPreviewGray = menu.add("Preview GRAY");

mItemPreviewCanny = menu.add("Canny");

mItemPreviewFeatures = menu.add("Find features");

return true;

}

@Override

public void onPause()

{

super.onPause();

if (mOpenCvCameraView != null)

mOpenCvCameraView.disableView();

SensorsManager.stop();

}

@Override

public void onResume()

{

super.onResume();

OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3,

this, mLoaderCallback);

SensorsManager.start();

}

public void onDestroy() {

super.onDestroy();

if (mOpenCvCameraView != null)

mOpenCvCameraView.disableView();

}

public void onCameraViewStarted(int width, int height) {

mRgba = new Mat(height, width, CvType.CV_8UC4);

mIntermediateMat = new Mat(height, width, CvType.CV_8UC4);

mGray = new Mat(height, width, CvType.CV_8UC1);

ha = mOpenCvCameraView.getHorizontalAngle();

hb = mOpenCvCameraView.getVerticalAngle();

List <Size> resolutions;

resolutions=mOpenCvCameraView.getResolutionList();

mOpenCvCameraView.setResolution(resolutions.get(7));

}

public void onCameraViewStopped() {

mRgba.release();

mGray.release();

mIntermediateMat.release();

}

public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

final int viewMode = mViewMode;

switch (viewMode) {

case VIEW_MODE_GRAY:

// input frame has gray scale format

Imgproc.cvtColor(inputFrame.gray(), mRgba,

Imgproc.COLOR_GRAY2RGBA, 4);

break;

case VIEW_MODE_RGBA:

// input frame has RBGA format

mRgba = inputFrame.rgba();

break;

case VIEW_MODE_CANNY:

// input frame has gray scale format

mRgba = inputFrame.rgba();

Imgproc.Canny(inputFrame.gray(), mIntermediateMat, 80, 100);

Imgproc.cvtColor(mIntermediateMat, mRgba,

Imgproc.COLOR_GRAY2RGBA, 4);

break;

case VIEW_MODE_FEATURES:

// input frame has RGBA format

mRgba = inputFrame.rgba();

mGray = inputFrame.gray();

FindFeatures(mGray.getNativeObjAddr(), mRgba.getNativeObjAddr(), sa,

sb, sc, ha, hb);

break;

}

return mRgba;

}

public boolean onOptionsItemSelected(MenuItem item) {

Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);

if (item == mItemPreviewRGBA) {

mViewMode = VIEW_MODE_RGBA;

} else if (item == mItemPreviewGray) {

mViewMode = VIEW_MODE_GRAY;

} else if (item == mItemPreviewCanny) {

mViewMode = VIEW_MODE_CANNY;

} else if (item == mItemPreviewFeatures) {

mViewMode = VIEW_MODE_FEATURES;

}



return true;

}

public native void FindFeatures(long matAddrGr, long matAddrRgba,

double sa, double sb, double sc, double ha, double hb);

}

#include <jni.h>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/features2d/features2d.hpp>

#include <vector>

#include "opencv2/video/tracking.hpp"

#include "opencv2/highgui/highgui.hpp"

#include <cmath>

#include <iostream>

#include <ctype.h>

#include <android/log.h>

#define APPNAME "MyApp"

using namespace std;

using namespace cv;

extern "C" {

//JNIEXPORT void JNICALL

Java_org_opencv_samples_tutorial2_Tutorial2Activity_FindFeatures(JNIEn

v*, jobject, jlong addrGray, jlong addrRgba);

JNIEXPORT void JNICALL

Java_org_opencv_samples_tutorial2_Tutorial2Activity_FindFeatures(JNIEn

v*, jobject, jlong addrGray, jlong addrRgba, jdouble sa, jdouble sb, jdouble

sc, jdouble ha, jdouble hb)

{

Mat& mGr = *(Mat*)addrGray;

Mat& mRgb = *(Mat*)addrRgba;

// vector<KeyPoint> v;

//

// FastFeatureDetector detector(110);

// detector.detect(mGr, v);

// for( unsigned int i = 0; i < v.size(); i++ )

// {

// const KeyPoint& kp = v[i];

// circle(mRgb, Point(kp.pt.x, kp.pt.y), 10, Scalar(255,0,0,255));

// }

std::vector<cv::Vec4i> lines;

std::vector<double> goodness;

cvtColor(mRgb, mRgb, COLOR_BGR2GRAY);

medianBlur ( mRgb, mRgb, 5 );

cv::Canny(mRgb, mRgb, 150, 300, 3);

cv::HoughLinesP(mRgb, lines, 1, CV_PI / 180*2, 10, 40, 10);

if (lines.size()>0)

{

double mx=mRgb.cols*0.5;

double my=mRgb.rows*0.8;

for (int i = 0; i < lines.size(); i++)

{

cv::Vec4i v = lines[i];

//lines[i][0] = 0;

//lines[i][1] = ((float)v[1] - v[3]) / (v[0] - v[2]) * -v[0] + v[1];

//lines[i][2] = image.cols;

//lines[i][3] = ((float)v[1] - v[3]) / (v[0] - v[2]) * (image.cols - v[2]) + v[3];

line(mRgb, Point(lines[i][0], lines[i][1]), Point(lines[i][2], lines[i][3]),

Scalar(255, 255, 255), 2, 8, 0);

goodness.push_back( min( (lines[i][0]-mx)*(lines[i][0]-mx)+(lines[i][1]-

my)*(lines[i][1]-my)

, (lines[i][2]-mx)*(lines[i][2]-mx)+(lines[i][3]-my)*(lines[i][3]-my)));

}

int best=0;

for (int i=0; i<lines.size(); i++)

{

if (goodness[i]<goodness[best]) {

best=i;

}

}

double totrackx,totracky;

if (lines[best][1]>lines[best][3]) {

totrackx=lines[best][0];

totracky=lines[best][1];

}

else {

totrackx=lines[best][2];

totracky=lines[best][3];

}

circle(mRgb, Point(totrackx, totracky), 10, Scalar(255,255,255,255),-1,8);

double pointangle=-sb+hb/2-(totracky/mRgb.rows)*hb;

double distance=1.5*tan(abs(pointangle*(3.14159265/180)));

std::ostringstream s;

s << "lines #" << lines.size() << "; dist:" << round(distance*100) << "cm";

putText(mRgb, s.str(), cvPoint(10, 70),

CV_FONT_HERSHEY_COMPLEX_SMALL, 0.8, cvScalar(255, 255,

255), 1, 8); }

}

//circle(mRgb, Point(100, 100), abs(round(sb))/4, Scalar(255,255,255,255),-

1,8);

Размещено на Allbest.ru