Программные средства для заполнения базы персональных данных

(обязательное)

Листинг класса BaseDocRecognitionService

package demidov.docrecognition;

import android.content.Context;

import android.content.Intent;

import android.hardware.Camera;

import android.os.Bundle;

import com.google.common.collect.ArrayListMultimap;

import com.google.common.collect.Multimap;

import com.google.common.collect.SortedSetMultimap;

import com.google.common.collect.TreeMultimap;

import org.bytedeco.javacpp.opencv_core;

import org.bytedeco.javacpp.opencv_core.Mat;

import org.bytedeco.javacpp.opencv_core.MatVector;

import org.bytedeco.javacpp.opencv_core.Rect;

import org.bytedeco.javacv.FFmpegFrameFilter;

import org.bytedeco.javacv.Frame;

import org.bytedeco.javacv.FrameFilter;

import org.bytedeco.javacv.OpenCVFrameConverter;

import java.nio.ByteBuffer;

import java.util.Collection;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static org.bytedeco.javacpp.avutil.AV_PIX_FMT_NV21;

import static org.bytedeco.javacpp.opencv_imgproc.CHAIN_APPROX_NONE;

import static org.bytedeco.javacpp.opencv_imgproc.CV_RGBA2GRAY;

import static org.bytedeco.javacpp.opencv_imgproc.INTER_AREA;

import static org.bytedeco.javacpp.opencv_imgproc.RETR_EXTERNAL;

import static org.bytedeco.javacpp.opencv_imgproc.approxPolyDP;

import static org.bytedeco.javacpp.opencv_imgproc.boundingRect;

import static org.bytedeco.javacpp.opencv_imgproc.cvtColor;

import static org.bytedeco.javacpp.opencv_imgproc.findContours;

import static org.bytedeco.javacpp.opencv_imgproc.rectangle;

import static org.bytedeco.javacpp.opencv_imgproc.resize;

public abstract class BaseDocRecognitionService {

private final Camera camera;

private final Context applicationContext;

private final Context context;

private final CvCameraPreview cameraView;

final Map<DocumentField, Rect> fieldsSearchingAreas;

final double previewToPictureRatio;

final Rect mask;

public BaseDocRecognitionService(int width, int height, Camera camera, Context applicationContext, Context context, CvCameraPreview cameraView) {

this.mask = getMask(width, height);

this.camera = camera;

this.previewToPictureRatio = ((double) camera.getParameters().getPreviewSize().height) /

camera.getParameters().getPictureSize().height;

this.fieldsSearchingAreas = calculateSearchingAreas(mask.size());

this.applicationContext = applicationContext;

this.context = context;

this.cameraView = cameraView;

}

public Mat processPreview(Mat image) {

Multimap<DocumentField, Rect> detectedFields = detect(image);

if (isAllFieldsFound(detectedFields.keySet())) {

takeFullSizePicture();

}

Mat preview = visualizeRects(image, detectedFields);

return preview;

}

public Multimap<DocumentField, Rect> detect(Mat image) {

Mat croppedImage = image.apply(mask);

cvtColor(croppedImage, croppedImage, CV_RGBA2GRAY);

findEdges(croppedImage);

applyMorphology(croppedImage);

return detectFields(croppedImage);

}

public Mat visualizeRects(Mat input, Multimap<DocumentField, Rect> fields) {

Mat croppedImage = input.apply(mask);

drawFieldRects(croppedImage, fields);

drawSearchingAreas(croppedImage, fieldsSearchingAreas);

return recoverToSize(input.size(), mask, croppedImage,

org.bytedeco.javacpp.helper.opencv_core.AbstractScalar.WHITE);

}

private boolean isAllFieldsFound(Collection<DocumentField> fields) {

return fields.containsAll(getAllFields());

}

void takeFullSizePicture() {

try {

camera.takePicture(null, null, new Camera.PictureCallback() {

@Override

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

Camera.Size pictureSize = camera.getParameters().getPictureSize();

Frame filteredFrame = filterFrame(data, pictureSize.width, pictureSize.height);

OpenCVFrameConverter.ToMat converterToMat = new OpenCVFrameConverter.ToMat();

Mat mat = converterToMat.convert(filteredFrame);

Mat smallImage = new Mat();

resize(mat, smallImage, new opencv_core.Size(),

previewToPictureRatio, previewToPictureRatio, INTER_AREA);

Multimap<DocumentField, Rect> detectedFields = detect(smallImage);

Map<DocumentField, String> fieldValues = recognize(mat, sortFields(detectedFields));

processToVerification(fieldValues);

}

});

} catch (RuntimeException e) {

}

}

private Frame filterFrame(byte[] data, int width, int height) {

Frame frame = new Frame(width, height, Frame.DEPTH_UBYTE, 2);

((ByteBuffer) frame.image[0].position(0)).put(data);

FFmpegFrameFilter filter = new FFmpegFrameFilter("transpose=1,format=pix_fmts=rgba", width, height);

filter.setPixelFormat(AV_PIX_FMT_NV21);

Frame filteredFrame = null;

try {

filter.start();

filter.push(frame);

filteredFrame = filter.pull();

filter.stop();

} catch (FrameFilter.Exception e) {

e.printStackTrace();

}

return filteredFrame;

}

void processToVerification(Map<DocumentField, String> fieldValues) {

Intent intent = new Intent(applicationContext, DocumentActivity.class);

Bundle bundle = new Bundle();

for (Map.Entry<DocumentField, String> entry : fieldValues.entrySet()) {

bundle.putString(entry.getKey().getName(), entry.getValue());

}

intent.putExtra("documentFields", bundle);

intent.putExtra("documentType", getDocumentType().name());

context.startActivity(intent);

}

abstract Map<DocumentField, String> recognize(Mat image, Multimap<DocumentField, Rect> fields);

abstract DocumentType getDocumentType();

Rect scaleRect(Rect input) {

int x = (int) ((mask.x() + input.x()) / previewToPictureRatio);

int y = (int) ((mask.y() + input.y()) / previewToPictureRatio);

int width = (int) (input.width() / previewToPictureRatio);

int height = (int) (input.height() / previewToPictureRatio);

return new Rect(x, y, width, height);

}

private Rect getMask(int width, int height) {

double docRatio = getRatio();

int x = 0, y = 0;

if (((double) width)/height > docRatio) {

double desiredWidth = height * docRatio;

int margin = (int) ((width - desiredWidth) / 2);

x = margin;

width = (int) desiredWidth;

} else {

double desiredHeight = width / docRatio;

int margin = (int) ((height - desiredHeight) / 2);

y = margin;

height = (int) desiredHeight;

}

return new Rect(x, y, width, height);

}

abstract void findEdges(Mat image);

abstract void applyMorphology(Mat input);

private Multimap<DocumentField, Rect> detectFields(Mat input) {

Multimap<DocumentField, Rect> detectedFields = ArrayListMultimap.create();

MatVector contours = new MatVector();

findContours(input, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);

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

Mat contour = new Mat();

approxPolyDP(contours.get(i), contour, 3, true);

Rect rect = boundingRect(contour);

rect.x(rect.x() - 3);

rect.y(rect.y() - 3);

rect.width(rect.width() + 6);

rect.height(rect.height() + 6);

DocumentField field = getFieldCorrespondingTo(rect);

if (field != null) {

detectedFields.put(field, rect);

}

}

return detectedFields;

}

private void drawFieldRects(Mat originalImage, Multimap<DocumentField, Rect> fields) {

for (Rect rect : fields.values()) {

rectangle(originalImage, rect, new opencv_core.Scalar(255, 0, 0, 0));

}

}

private void drawSearchingAreas(Mat originalImage, Map<DocumentField, Rect> areas) {

for (Rect rect : areas.values()) {

rectangle(originalImage, rect, new opencv_core.Scalar(0, 255, 0, 0));

}

}

private DocumentField getFieldCorrespondingTo(Rect textRect) {

for (Map.Entry<DocumentField, Rect> entry : fieldsSearchingAreas.entrySet()) {

Rect value = entry.getValue();

if (value.contains(textRect.br()) && value.contains(textRect.tl())) {

return entry.getKey();

}

}

return null;

}

private Mat recoverToSize(opencv_core.Size size, Rect mask,

Mat image, opencv_core.Scalar backgroundColor) {

Mat result = new Mat(size, image.type(), backgroundColor);

image.copyTo(result.apply(mask));

return result;

}

abstract double getRatio();

abstract List<DocumentField> getAllFields();

SortedSetMultimap<DocumentField, Rect> sortFields(Multimap<DocumentField, Rect> fieldsToSort) {

SortedSetMultimap<DocumentField, Rect> result = TreeMultimap.create(new Comparator<DocumentField>() {

@Override

public int compare(DocumentField o1, DocumentField o2) {

if (o1.getRelativeSearchingArea().y() > o2.getRelativeSearchingArea().y()) {

return 1;

} else if (o1.getRelativeSearchingArea().y() < o2.getRelativeSearchingArea().y()) {

return -1;

} else if (o1.getRelativeSearchingArea().x() > o2.getRelativeSearchingArea().x()) {

return 1;

} else if (o1.getRelativeSearchingArea().x() < o2.getRelativeSearchingArea().x()) {

return -1;

} else {

return 0;

}

}

}, new Comparator<Rect>() {

@Override

public int compare(Rect o1, Rect o2) {

return o1.y() - o2.y();

}

});

result.putAll(fieldsToSort);

return result;

}

private Map<DocumentField, Rect> calculateSearchingAreas(opencv_core.Size imageSize) {

Map<DocumentField, Rect> result = new HashMap<>();

for (DocumentField field : getAllFields()) {

opencv_core.Rectd relativeSearchingArea = field.getRelativeSearchingArea();

int x = (int) (imageSize.width() * relativeSearchingArea.x());

int y = (int) (imageSize.height() * relativeSearchingArea.y());

int width = (int) (imageSize.width() * relativeSearchingArea.width());

int height = (int) (imageSize.height() * relativeSearchingArea.height());

result.put(field, new Rect(x, y, width, height));

}

return result;

}

}

ПРИЛОЖЕНИЕ 14