Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • aricca/chessTrack
  • nicolas.furquez/chessTrack
2 results
Show changes
Commits on Source (47)
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1156 additions and 487 deletions
LICENSE.md 0 → 100644
View file @ a2136e1b
This diff is collapsed.
ProyectoAndroid/ChessTrack/AndroidManifest.xml
View file @ a2136e1b
......@@ -3,8 +3,6 @@
android:versionCode="1"
android:versionName="1.0" >
<!-- <application -->
<!-- android:allowBackup="true" -->
<!-- android:icon="@drawable/ic_launcher" -->
......@@ -12,8 +10,6 @@
<!-- android:theme="@style/AppTheme" > -->
<!-- </application> -->
<application
android:allowBackup="true"
android:label="@string/app_name"
......@@ -30,22 +26,21 @@
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-sdk
android:minSdkVersion="9"
android:targetSdkVersion="10" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
......
ProyectoAndroid/ChessTrack/bin/AndroidManifest.xml deleted 100644 → 0
View file @ fdd60c21
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="uy.edu.fing.chesstrack"
android:versionCode="1"
android:versionName="1.0" >
<!-- <application -->
<!-- android:allowBackup="true" -->
<!-- android:icon="@drawable/ic_launcher" -->
<!-- android:label="@string/app_name" -->
<!-- android:theme="@style/AppTheme" > -->
<!-- </application> -->
<application
android:allowBackup="true"
android:label="@string/app_name"
android:icon="@drawable/ic_launcher"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="ChessTrackActivity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-sdk
android:minSdkVersion="9"
android:targetSdkVersion="10" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/ChessTrackActivity.java
View file @ a2136e1b
package uy.edu.fing.chesstrack;
import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
......@@ -9,135 +8,174 @@ import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.Mat;
import uy.edu.fing.chesstrack.modulomodelador.Modelador;
import uy.edu.fing.chesstrack.modulovision.Adquisicion;
import uy.edu.fing.chesstrack.modulovision.Calibracion;
import uy.edu.fing.chesstrack.modulovision.Manager;
import android.app.Activity;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.text.Editable;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.SurfaceView;
import android.view.WindowManager;
import android.widget.EditText;
public class ChessTrackActivity extends Activity implements CvCameraViewListener {
public class ChessTrackActivity extends Activity implements
CvCameraViewListener {
private static final String TAG = "CHESSTRACK::Activity";
private static final String IPV4_REGEX = "^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$";
private static final String PORT_REGEX = "^(\\d{4,5})$";
// estados
private static final int IDLE = 0;
private static final int CALIBRAR = 1;
private static final int JUGAR = 2;
private CameraBridgeViewBase mOpenCvCameraView;
//private JavaCameraView mOpenCvCameraView;
private CameraBridgeViewBase _mOpenCvCameraView;
// private JavaCameraView _mOpenCvCameraView;
private Adquisicion adq;
private Calibracion calibrar;
private Manager _manager;
private MenuItem _mItemCalibrar;
private MenuItem _mItemServer;
private int _estado;
private MenuItem mItemCalibrar;
//TODO es chancho pero ver luego
private Mat frame;
private boolean isUsed;
private boolean isCalibrada ;
private final BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(
this) {
private final BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
@Override
public void onManagerConnected(int status) {
switch (status) {
case LoaderCallbackInterface.SUCCESS:
{
case LoaderCallbackInterface.SUCCESS: {
Log.i(TAG, "OpenCV loaded successfully");
mOpenCvCameraView.enableView();
} break;
default:
{
_mOpenCvCameraView.enableView();
}
break;
default: {
super.onManagerConnected(status);
} break;
}
break;
}
}
};
@Override
public void onResume()
{
public void onResume() {
super.onResume();
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this, mLoaderCallback);
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this,
mLoaderCallback);
}
@Override
public void onCreate(Bundle savedInstanceState) {
Log.i(TAG, "called onCreate");
super.onCreate(savedInstanceState);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
setContentView(R.layout.chess_track_layout);
mOpenCvCameraView = (JavaCameraView) findViewById(R.id.chess_track_layout);
mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
mOpenCvCameraView.setCvCameraViewListener(this);
_mOpenCvCameraView = (JavaCameraView) findViewById(R.id.chess_track_layout);
_mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
_mOpenCvCameraView.setCvCameraViewListener(this);
_manager = Manager.getInstance();
}
Modelador.getInstance();
try {
public void getServerIp() {
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Communication Setup");
alert.setMessage("Set server ip");
final EditText input = new EditText(this);
alert.setView(input);
alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int whichButton) {
Editable value = input.getText();
if (value == null || value.toString().equals("")
|| !value.toString().matches(IPV4_REGEX)) {
Log.i(TAG, "INPUT= not valid IP" + value.toString());
getServerIp();
} else {
Log.i(TAG, "INPUT=" + value.toString());
Log.i(TAG, "IP=" + value.toString());
getServerPort(value.toString());
}
}
});
isUsed = false;
isCalibrada =false;
alert.show();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
public void getServerPort(final String ip) {
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Communication Setup");
alert.setMessage("Set server port");
final EditText input = new EditText(this);
alert.setView(input);
alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int whichButton) {
Editable value = input.getText();
Log.i(TAG, "INPUT=" + value.toString());
if (value == null || value.toString().equals("")
|| !value.toString().matches(PORT_REGEX)) {
Log.i(TAG, "INPUT= not valid PORT" + value.toString());
getServerPort(ip);
} else {
Log.i(TAG, "INPUT=" + value.toString());
int port = Integer.parseInt(value.toString());
Log.i(TAG, "PORT=" + port);
_manager.setConnection(ip, port);
}
}
});
alert.show();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
Log.i(TAG, "called onCreateOptionsMenu");
mItemCalibrar = menu.add("Show/hide tile numbers");
_mItemCalibrar = menu.add("Calibrar..");
_mItemServer = menu.add("Conectar Server");
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Log.i(TAG, "Menu Item selected " + item);
if (item == mItemCalibrar) {
isUsed = true;
if(frame!=null){
if (Calibracion.getInstance().calibrar(frame)){
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // 200 is duration in ms
try {
adq = new Adquisicion();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
isCalibrada = true;
}else{
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 700); // 200 is duration in ms
}
if (item == _mItemCalibrar) {
if (_estado == IDLE) {
_estado = CALIBRAR;
}
isUsed = false;
} else if (item == _mItemServer) {
getServerIp();
}
return true;
}
@Override
public void onPause()
{
public void onPause() {
super.onPause();
if (mOpenCvCameraView != null) {
mOpenCvCameraView.disableView();
if (_mOpenCvCameraView != null) {
_mOpenCvCameraView.disableView();
}
}
@Override
public void onDestroy() {
super.onDestroy();
if (mOpenCvCameraView != null) {
mOpenCvCameraView.disableView();
if (_mOpenCvCameraView != null) {
_mOpenCvCameraView.disableView();
}
if (_manager != null) {
_manager.destroy();
}
}
......@@ -151,22 +189,24 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
@Override
public Mat onCameraFrame(Mat inputFrame) {
// TODO MANEJAR ESTADOS
if (!isUsed){
frame = inputFrame;
}
if(isCalibrada){
Log.i(TAG, "calibrada");
inputFrame = adq.processFrame(inputFrame);
Modelador.getInstance().dividirTablero(inputFrame);
return Modelador.getInstance().dibujarEscaque();
//return inputFrame;
if (inputFrame != null) {
switch (_estado) {
case CALIBRAR:
Log.i(TAG, "calibrando...");
if (_manager.calibrar(inputFrame)) {
_estado = JUGAR;
} else {
_estado = IDLE;
}
break;
case JUGAR:
Log.i(TAG, "jugando...");
_manager.processFrame(inputFrame);
break;
case IDLE:
break;
}
}
return inputFrame;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/ajedrez/Logica.java 0 → 100644
View file @ a2136e1b
package uy.edu.fing.chesstrack.ajedrez;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Size;
public class Logica {
private static final String TAG = "CHESSTRACK::Logica";
private Mat _tableroInicio;
private Mat _tableroAnterior;
public Logica() {
double[] vectorONES = { 1, 1, 1, 1, 1, 1, 1, 1 };
_tableroInicio = Mat.zeros(new Size(8, 8), CvType.CV_8UC1);
_tableroInicio.put(0, 0, vectorONES);
_tableroInicio.put(1, 0, vectorONES);
_tableroInicio.put(6, 0, vectorONES);
_tableroInicio.put(7, 0, vectorONES);
_tableroAnterior = _tableroInicio;
}
public Mat getTableroInicio() {
return _tableroInicio;
}
public boolean validarNuevoTablero(Mat actual) {
Mat result = new Mat(8, 8, CvType.CV_8UC1);
Core.absdiff(actual, _tableroAnterior, result);
if (Core.countNonZero(result) != 0) {
_tableroAnterior = actual;
}
return (Core.countNonZero(result) != 0);
}
public boolean validarTableroArmado(Mat nuevo) {
Mat result = new Mat(8, 8, CvType.CV_8UC1);
Core.absdiff(nuevo, _tableroInicio, result);
return (Core.countNonZero(result) == 0);
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/communication/Client.java 0 → 100644
View file @ a2136e1b
package uy.edu.fing.chesstrack.communication;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import android.util.Log;
public class Client {
private static final String TAG = "CLIENT";
private static Client _clientInstance;
private Socket serverSocket;
private int _serverPort = 5556;
private String _serverIp = "192.168.1.23";
// private BufferedReader input;
private DataOutputStream output;
protected Client() {
}
public static Client getInstance() {
if (_clientInstance == null) {
_clientInstance = new Client();
}
return _clientInstance;
}
public void EstablishConnection(String serverIp, int serverPort) {
Log.i(TAG, "init client-server communication");
this._serverIp = serverIp;
this._serverPort = serverPort;
try {
Log.i(TAG, "Server on " + this._serverIp + ":" + _serverPort);
InetAddress serverAddr = InetAddress.getByName(this._serverIp);
serverSocket = new Socket(serverAddr, _serverPort);
// get stream to send data
this.output = new DataOutputStream(
this.serverSocket.getOutputStream());
// get stream to receive data
// this.input = new BufferedReader(new
// InputStreamReader(this.serverSocket.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}
public void SendData(String msg) {
try {
Log.i(TAG, "sending=" + msg);
this.output.writeBytes(msg);
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* public String ReceiveData() { try { String read = input.readLine();
* Log.i(TAG, "received="+ read); return read; } catch (IOException e) {
* e.printStackTrace(); return null; } }
*/
public void Stop() {
try {
// input.close();
output.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulomodelador/Modelador.java
View file @ a2136e1b
package uy.edu.fing.chesstrack.modulomodelador;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;
import uy.edu.fing.chesstrack.modulovision.Calibracion;
import android.util.Log;
public class Modelador {
private static final String TAG = "CHESSTRACK::Modelador";
private final int CANT_FILAS= 8;
private final int CANT_SCAQUE = CANT_FILAS* CANT_FILAS;
private final int[][] tablero;
private final int CANT_FILAS = 8;
// private final int CANT_SCAQUE = CANT_FILAS * CANT_FILAS;
private final int MIN_CANT_PIX_WHITE = 30;
private Mat tablero;
// se cuentan de arrib a abajo y de izquierda a derecha
private final Mat[][] escaques;
private static Modelador instance;
// private static Modelador instance;
private Modelador(){
tablero = new int[CANT_FILAS][CANT_FILAS];
public Modelador() {
tablero = Mat.zeros(new Size(8, 8), CvType.CV_8UC1);
escaques = new Mat[CANT_FILAS][CANT_FILAS];
//TODO init tablero
}
public static Modelador getInstance(){
if (instance == null){
instance = new Modelador();
}
return instance;
}
public void dividirTablero(Mat inputFrame){
Rect roi = Calibracion.getInstance().getRectPOI();
Mat proccesFrame = inputFrame.submat(roi);
int largo = proccesFrame.rows();
int ancho = proccesFrame.cols();
public void dividirTablero(Mat inputFrame) {
Imgproc.cvtColor(inputFrame, inputFrame, Imgproc.COLOR_RGBA2GRAY, 4);
int largo = inputFrame.rows();
int ancho = inputFrame.cols();
// obtengo cuanto mide en ancho y largo un escaque
int largoEscaque = (int) Math.floor(largo /(CANT_FILAS+1) );//+1 porque se toma un escaque mas de borde
int anchoEscaque = (int) Math.floor(ancho /(CANT_FILAS+1) );
int largoEscaque = (int) Math.floor(largo / (CANT_FILAS + 2));// +2
// porque
// se
// toma
// un
// escaque
// mas
// de
// borde
int anchoEscaque = (int) Math.floor(ancho / (CANT_FILAS + 2));
Log.i(TAG, "largoEscaque= " + largoEscaque);
Log.i(TAG, "anchoEscaque= " + anchoEscaque);
for (int i = 0; i < CANT_FILAS; i++){
for (int j = 0; j < CANT_FILAS; j++){
int rowStart=(int)Math.floor(largoEscaque/2)+ i*largoEscaque +2;
int rowEnd = (int)Math.floor(largoEscaque/2)+i*largoEscaque + largoEscaque -2;
int colStart = (int)Math.floor(anchoEscaque/2)+j*anchoEscaque + 2;
int colEnd = (int)Math.floor(anchoEscaque/2)+j*anchoEscaque + anchoEscaque - 2;;
escaques[i][j]= inputFrame.submat(rowStart, rowEnd, colStart, colEnd);
for (int i = 0; i < CANT_FILAS; i++) {
for (int j = 0; j < CANT_FILAS; j++) {
int rowStart = (int) Math.floor(largoEscaque) + i
* largoEscaque + 4;
int rowEnd = (int) Math.floor(largoEscaque) + i * largoEscaque
+ largoEscaque - 4;
int colStart = (int) Math.floor(anchoEscaque) + j
* anchoEscaque + 4;
int colEnd = (int) Math.floor(anchoEscaque) + j * anchoEscaque
+ anchoEscaque - 4;
escaques[i][j] = inputFrame.submat(colStart, colEnd, rowStart,
rowEnd);
}
}
}
private int getHayFichaEnEscaque(int i, int j) {
int ret = 0;
Mat mIntermediateMat = new Mat();
Imgproc.Sobel(escaques[i][j], mIntermediateMat, CvType.CV_8U, 1, 1);
Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
Imgproc.threshold(mIntermediateMat, mIntermediateMat, 70, 255,
Imgproc.THRESH_BINARY);
// int cant_pix = mIntermediateMat.cols() * mIntermediateMat.rows();
int cant_pix_white = Core.countNonZero(mIntermediateMat);
if (cant_pix_white > (MIN_CANT_PIX_WHITE)) {
ret = 1;
}
return ret;
}
public Mat getMatrizFichas(Mat frame) {
dividirTablero(frame);
tablero = Mat.zeros(new Size(8, 8), CvType.CV_8UC1);
for (int i = 0; i < CANT_FILAS; i++) {
for (int j = 0; j < CANT_FILAS; j++) {
tablero.put(i, j, getHayFichaEnEscaque(i, j));
}
}
return tablero.t();
}
public Mat dibujarEscaque() {
Mat tmp = Mat.ones(Calibracion.getInstance().get_sizeFrame(),
CvType.CV_8UC4);
Mat subm; // tmp.submat(new Rect(new Point(0,0)
// ,escaques[i][j].size()));
// escaques[i][j].copyTo(subm);
int pos_x = 0;
int pos_y = 0;
for (int i = 0; i < CANT_FILAS; i++) {
for (int j = 0; j < CANT_FILAS; j++) {
pos_x = (int) (escaques[i][j].size().width * i);
pos_y = (int) (escaques[i][j].size().height * j);
subm = tmp.submat(new Rect(new Point(pos_x, pos_y),
escaques[i][j].size()));
escaques[i][j].copyTo(subm);
Core.putText(tmp,
Integer.toString(i) + "-" + Integer.toString(j),
new Point(pos_x + 1, pos_y + 1),
Core.FONT_HERSHEY_SIMPLEX, 0.3, new Scalar(255, 0, 0));
}
}
return tmp;
}
public Mat dibujarEscaque(){
Mat tmp = Mat.zeros(Calibracion.getInstance().getImagenCalibrada().size(), CvType.CV_8UC4);
Mat subm ; //tmp.submat(new Rect(new Point(0,0) ,escaques[i][j].size()));
//escaques[i][j].copyTo(subm);
public Mat dibujarEscaquesCanny() {
Mat tmp = Mat.zeros(Calibracion.getInstance().get_sizeFrame(),
CvType.CV_8UC4);
Mat subm; // tmp.submat(new Rect(new Point(0,0)
// ,escaques[i][j].size()));
// escaques[i][j].copyTo(subm);
Mat mIntermediateMat = new Mat();
int pos_x = 0;
int pos_y = 0;
for (int i = 0; i < CANT_FILAS; i++){
for (int j = 0; j < CANT_FILAS; j++){
subm = tmp.submat(new Rect(new Point(pos_x,pos_y) ,escaques[i][j].size()));
for (int i = 0; i < CANT_FILAS; i++) {
for (int j = 0; j < CANT_FILAS; j++) {
pos_x = (int) (escaques[i][j].size().width * i);
pos_y = (int) (escaques[i][j].size().height * j);
subm = tmp.submat(new Rect(new Point(pos_x, pos_y),
escaques[i][j].size()));
Imgproc.Canny(escaques[i][j], mIntermediateMat, 80, 90);
Imgproc.cvtColor(mIntermediateMat, subm,
Imgproc.COLOR_GRAY2RGBA, 4);
escaques[i][j].copyTo(subm);
pos_x = (int) (escaques[i][j].size().width*i +1);
pos_y = (int) (escaques[i][j].size().height*j +1);
Core.putText(tmp,
Integer.toString(i) + "-" + Integer.toString(j),
new Point(pos_x + 1, pos_y + 1),
Core.FONT_HERSHEY_SIMPLEX, 0.3, new Scalar(255, 0, 0));
}
}
return tmp;
}
public Mat dibujarEscaquesSobel(int version) {
Mat tmp = Mat.zeros(Calibracion.getRectROI().size(), CvType.CV_8UC4);
Mat subm; // tmp.submat(new Rect(new Point(0,0)
// ,escaques[i][j].size()));
// escaques[i][j].copyTo(subm);
Mat mIntermediateMat = new Mat();
int pos_x = 0;
int pos_y = 0;
Log.i(TAG, "cant_pix_INI");
for (int i = 0; i < CANT_FILAS; i++) {
for (int j = 0; j < CANT_FILAS; j++) {
pos_x = (int) (escaques[i][j].size().width * i);
pos_y = (int) (escaques[i][j].size().height * j);
subm = tmp.submat(new Rect(new Point(pos_x, pos_y),
escaques[i][j].size()));
// Imgproc.cvtColor(escaques[i][j] ,mIntermediateMat,
// Imgproc.COLOR_RGBA2GRAY,4);
Imgproc.Sobel(escaques[i][j], mIntermediateMat, CvType.CV_8U,
1, 1);
Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
Imgproc.threshold(mIntermediateMat, mIntermediateMat, 70, 255,
Imgproc.THRESH_BINARY);
Imgproc.erode(mIntermediateMat, mIntermediateMat, Imgproc
.getStructuringElement(Imgproc.MORPH_RECT, new Size(1,
1)));
Imgproc.dilate(mIntermediateMat, mIntermediateMat, Imgproc
.getStructuringElement(Imgproc.MORPH_RECT, new Size(1,
1)));
int cant_pix = mIntermediateMat.cols()
* mIntermediateMat.rows();
int cant_pix_white = Core.countNonZero(mIntermediateMat);
Log.i(TAG, "cant_pix=" + cant_pix);
Log.i(TAG, "cant_pix_white=" + cant_pix_white);
switch (version) {
case 1:
if (cant_pix_white > (MIN_CANT_PIX_WHITE)) {
Imgproc.cvtColor(mIntermediateMat, subm,
Imgproc.COLOR_GRAY2RGBA, 4);
} else {
Imgproc.cvtColor(escaques[i][j], subm,
Imgproc.COLOR_GRAY2RGBA, 4);
}
break;
case 2:
if (cant_pix_white > (MIN_CANT_PIX_WHITE)) {
Log.i(TAG, "NUEVA FICHA" + (i + 1) + "-" + (j + 1));
}
Imgproc.cvtColor(mIntermediateMat, subm,
Imgproc.COLOR_GRAY2RGBA, 4);
break;
default:
Imgproc.cvtColor(escaques[i][j], subm,
Imgproc.COLOR_GRAY2RGBA, 4);
break;
}
}
}
Log.i(TAG, "cant_pix_FIN");
return tmp;
}
......
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/Adquisicion.java
View file @ a2136e1b
package uy.edu.fing.chesstrack.modulovision;
import java.util.ArrayList;
import java.util.List;
......@@ -11,24 +9,18 @@ import uy.edu.fing.chesstrack.modulovision.imgproc.Homografia;
import uy.edu.fing.chesstrack.modulovision.imgproc.ImgProcInterface;
import android.util.Log;
public class Adquisicion {
List<ImgProcInterface> listProc;
private static final String TAG = "CHESSTRACK::Adquisicion";
List<ImgProcInterface> _listProc;
public Adquisicion() throws Exception {
super();
Log.i(TAG, "Cargado....");
listProc = new ArrayList<ImgProcInterface>();
listProc.add( new Homografia());
//listProc.add( new EcualizarImagen());
//listProc.add( new SustraccionDeFondo());
//listProc.add( new BackgroundSupress());
_listProc = new ArrayList<ImgProcInterface>();
_listProc.add(new Homografia());
//_listProc.add(new EcualizarImagen());
}
/**
......@@ -40,12 +32,10 @@ public class Adquisicion {
*/
public synchronized Mat processFrame(Mat inputPicture) {
Log.i(TAG, "processFrame inicia");
Mat salida = inputPicture;
Mat prevImg = inputPicture;
for (ImgProcInterface proc: listProc){
prevImg = proc.procesarImagen(prevImg);
Mat tempImg = inputPicture;
for (ImgProcInterface proc: _listProc){
tempImg = proc.procesarImagen(tempImg);
}
return prevImg;
return tempImg;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/Calibracion.java
View file @ a2136e1b
......@@ -8,76 +8,64 @@ import org.opencv.core.Size;
import android.util.Log;
public class Calibracion {
private Mat imagenCalibrada;
private Mat imagenOriginal;
private MatOfPoint2f vertices;
public class Calibracion {
private static final String TAG = "CHESSTRACK::Calibracion";
private static Rect rectPOI = null;
private static Calibracion instance;
private Size _sizeFrame = null;
private MatOfPoint2f _vertices = null;
private static Rect _rectROI = null;
private static Calibracion _instance;
protected Calibracion(){
protected Calibracion() {
}
public static Calibracion getInstance(){
if(instance == null){
instance = new Calibracion();
public static Calibracion getInstance() {
if (_instance == null) {
_instance = new Calibracion();
}
return instance;
return _instance;
}
public boolean calibrar(Mat img){
public boolean calibrar(Mat img) {
Log.i(TAG, "INI calibrando");
boolean OK = false;
imagenOriginal = img;
imagenCalibrada = img;
Size patternSize = new Size(7,7);
Size patternSize = new Size(7, 7);
MatOfPoint2f corners = new MatOfPoint2f();
boolean ret = Calib3d.findChessboardCorners(imagenOriginal, patternSize, corners);
if (ret){
boolean ret = Calib3d.findChessboardCorners(img, patternSize, corners);
if (ret) {
Log.i(TAG, "Encontro = " + corners.total());
Log.i(TAG, "Encontro = " + corners.size().toString());
Calib3d.drawChessboardCorners(imagenCalibrada, patternSize, corners, ret);
vertices = corners;
// Calib3d.drawChessboardCorners(img, patternSize, corners, ret);
// only for debug
_vertices = corners;
_sizeFrame = img.size();
}
OK = ret;
Log.i(TAG, "FIN calibrando = " + ret);
return OK;
return ret;
}
public Mat getImagenCalibrada() {
return imagenCalibrada;
public Size get_sizeFrame() {
return _sizeFrame;
}
public void setImagenCalibrada(Mat imagenCalibrada) {
this.imagenCalibrada = imagenCalibrada;
public void set_sizeFrame(Size _sizeFrame) {
this._sizeFrame = _sizeFrame;
}
public MatOfPoint2f getVertices() {
return vertices;
return _vertices;
}
public void setVertices(MatOfPoint2f vertices) {
this.vertices = vertices;
this._vertices = vertices;
}
public static Rect getRectPOI() {
return rectPOI;
public static Rect getRectROI() {
return _rectROI;
}
public static void setRectPOI(Rect rectPOI) {
Calibracion.rectPOI = rectPOI;
public static void setRectROI(Rect rectROI) {
Calibracion._rectROI = rectROI;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/DetectorOclusion.java 0 → 100644
View file @ a2136e1b
package uy.edu.fing.chesstrack.modulovision;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;
import org.opencv.video.BackgroundSubtractorMOG2;
import android.util.Log;
public class DetectorOclusion {
private static final String TAG = "CHESSTRACK::BackgroundSupress";
private static final int OCLUSION = 0;
private static final int ESTABLE = 1;
private static final int TRANSICION = 2;
private static final int ENVIAR_TABLERO = 3;
private static final int START = -1;
private final Mat _fgMaskMOG2;
private Mat _resultado;
private BackgroundSubtractorMOG2 _pMOG2;
private final Mat _morphKernel;
private int _estadoANTERIOR;
private int _estadoACTUAL;
public DetectorOclusion() {
super();
Log.i(TAG, "constructor INI");
_morphKernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT,
new Size(3, 3));
_fgMaskMOG2 = new Mat(4, 1, CvType.CV_8UC1);
_pMOG2 = new BackgroundSubtractorMOG2();
_estadoACTUAL = START;
_resultado = new Mat();
Log.i(TAG, "constructor FIN");
}
public Mat get_resultado() {
return _resultado;
}
public void set_resultado(Mat _resultado) {
this._resultado = _resultado;
}
public boolean hayNuevoTableroValido(Mat inputFrame) {
/*
* if (_estadoACTUAL == START){ _pMOG2 = new BackgroundSubtractorMOG2();
* // MOG2 approach }
*/
Log.i(TAG, "Procesar!");
Log.i(TAG, "Region SIZE=" + inputFrame.size());
_pMOG2.apply(inputFrame, _fgMaskMOG2);
Imgproc.erode(_fgMaskMOG2, _fgMaskMOG2, _morphKernel);
Log.i(TAG, "Apply erode");
Imgproc.threshold(_fgMaskMOG2, _fgMaskMOG2, 200, 255,
Imgproc.THRESH_BINARY);
Log.i(TAG, "Apply threshold");
// Imgproc.dilate(_fgMaskMOG2, _fgMaskMOG2, _morphKernel);
// Log.i(TAG, "Apply dilate");
Scalar suma = Core.sumElems(_fgMaskMOG2);
Log.i(TAG, "SUMA = " + suma);
_estadoANTERIOR = _estadoACTUAL;
if (suma.val[0] > 1250000) {
Log.i(TAG, "VEO MANO !!!");
_estadoACTUAL = OCLUSION;
/*
* Core.putText(_fgMaskMOG2, "MANO !!!", new Point(20, 20),
* Core.FONT_HERSHEY_SIMPLEX, 0.8, new Scalar(255, 255, 0));
*/
} else {
if (_estadoANTERIOR == OCLUSION) {
/*
* Core.putText(_fgMaskMOG2, "TRANSI !!!", new Point(20, 20),
* Core.FONT_HERSHEY_SIMPLEX, 0.8, new Scalar(255, 255, 0));
*/
Log.i(TAG, "VEO TRANSICION !!!");
_estadoACTUAL = TRANSICION;
}
if (_estadoANTERIOR == TRANSICION) {
/*
* Core.putText(_fgMaskMOG2, "ESTABLE !!!", new Point(20, 20),
* Core.FONT_HERSHEY_SIMPLEX, 0.8, new Scalar(255, 255, 0));
*/
_estadoACTUAL = ENVIAR_TABLERO;
_pMOG2 = new BackgroundSubtractorMOG2(); // MOG2 approach
Log.i(TAG, "VEO ENVIAR !!!");
}
if (_estadoANTERIOR == ENVIAR_TABLERO) {
_estadoACTUAL = ESTABLE;
Log.i(TAG, "VEO ESTABLE !!!");
}
}
Log.i(TAG, "END");
Imgproc.cvtColor(_fgMaskMOG2, _resultado, Imgproc.COLOR_GRAY2RGBA, 4);
return (_estadoACTUAL == ENVIAR_TABLERO);
}
}
/*
* double maxArea = 0; MatOfPoint largestContour = null;
* Imgproc.findContours(_fgMaskMOG2, contours, new Mat(), Imgproc.RETR_LIST,
* Imgproc.CHAIN_APPROX_TC89_L1); for (MatOfPoint contour : contours) { double
* area = Imgproc.contourArea(contour); if (area > maxArea) { maxArea = area;
* largestContour = contour; } } Log.i(TAG, "ESTABLE !!!" + maxArea); if
* ((largestContour != null) && (maxArea > 10000)){ Log.i(TAG, "MANO !!!" +
* maxArea); Rect boundingRect = Imgproc.boundingRect(largestContour);
* ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
* toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // 200 is
* duration in ms }
*/
/*
* Imgproc.findContours(_fgMaskMOG2, contours, new Mat(), Imgproc.RETR_LIST,
* Imgproc.CHAIN_APPROX_NONE);
*
* for(int idx = 0; idx < contours.size(); idx++) { double area =
* Imgproc.contourArea(contours.get(idx)); Log.i(TAG, "CONTOUR = AREA: " +
* area); if ((area > 15000) && (area < 70000)){ Log.i(TAG, "DRAW !!! : " +
* area); Scalar color = new Scalar(255,127,127); Rect r =
* Imgproc.boundingRect(contours.get(idx)); Log.i(TAG,
* "3 at backgroundS "+(_fgMaskMOG2.type() == CvType.CV_8UC1));
* Core.rectangle(_fgMaskMOG2, r.tl(), r.br(), color, 2, 8, 0);
* //Imgproc.drawContours(_fgMaskMOG2, contours, idx, color); } }
*
* contours.clear();
*/
\ No newline at end of file
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/Manager.java 0 → 100644
View file @ a2136e1b
package uy.edu.fing.chesstrack.modulovision;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import uy.edu.fing.chesstrack.ajedrez.Logica;
import uy.edu.fing.chesstrack.communication.Client;
import uy.edu.fing.chesstrack.modulomodelador.Modelador;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.util.Log;
public class Manager {
private static final String TAG = "CHESSTRACK::MANAGER";
private static Manager _instance;
private static final int ARMANDO_TABLERO = 0;
private static final int JUGANDO = 1;
private static final int OK = 1;
private static final int NOT = 0;
private static final String WELCOME_MSG = ""
+ "--------------------------------------------------------------------------\n"
+ " .:: CHESSTRACK ::. seguimiento de una partida de Ajedrez\n"
+ "\n"
+ " TImag 2014\n"
+ " Nicolas Furquez - Aylen Ricca\n"
+ "--------------------------------------------------------------------------\n";
private static int _estado;
private static int _salida;
private static Adquisicion _adquisicion;
private static Client _client;
private static DetectorOclusion _detectorOclusion;
private static Modelador _modelador;
private static Logica _logica;
private final boolean _debug;
private int _cantJugada;
protected Manager() {
_estado = ARMANDO_TABLERO;
_salida = NOT;
_adquisicion = null;
_client = null;
_debug = false;
_cantJugada = 0;
}
public static Manager getInstance() {
if (_instance == null) {
_instance = new Manager();
}
return _instance;
}
public static int get_estado() {
return _estado;
}
public static void set_estado(int _estado) {
Manager._estado = _estado;
}
public void setConnection(String ip, int port) {
Log.i(TAG, "Setting connection");
_client = Client.getInstance();
_client.EstablishConnection(ip, port);
_client.SendData(WELCOME_MSG);
_salida = OK;
}
public boolean calibrar(Mat frame) {
Log.i(TAG, "Calibrando");
if (Calibracion.getInstance().calibrar(frame)) {
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM,
50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // ms
if (_salida == OK) {
_client.SendData("FIN calibrar\n . . . armando tablero!\n");
}
try {
_adquisicion = new Adquisicion();
_modelador = new Modelador();
_logica = new Logica();
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
Log.i(TAG, "No calibrado");
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 700);
return false;
}
public void iniciarJuego() {
_estado = JUGANDO;
// beep
_detectorOclusion = new DetectorOclusion();
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // ms
if (_salida == OK) {
Mat tableroInicio = _logica.getTableroInicio();
_client.SendData("TableroINICIO!\n");
_client.SendData(" ".concat(tableroInicio.dump().concat("\n")));
}
}
public Mat processFrame(Mat inputFrame) {
Log.i(TAG, "Acondicionamiento");
Mat region = _adquisicion.processFrame(inputFrame);
Log.i(TAG, "TYPE=" + (inputFrame.type() == CvType.CV_8UC4));
Log.i(TAG, "CHANNEL=" + (inputFrame.channels() == 4));
switch (_estado) {
case ARMANDO_TABLERO:
Log.i(TAG, "Armando Tablero");
Mat nuevo = _modelador.getMatrizFichas(region);
if (_logica.validarTableroArmado(nuevo)) {
iniciarJuego();
}
break;
case JUGANDO:
Log.i(TAG, "Jugando");
if (_detectorOclusion.hayNuevoTableroValido(region)) {
Log.i(TAG, "Tablero Valido");
// llamar al modelador
Mat aux = _modelador.getMatrizFichas(region);
// Log.i(TAG, "MATRIZ=" + aux.dump());
// region = _modelador.dibujarEscaquesSobel(2);
if (_logica.validarNuevoTablero(aux)) {
if (_salida == OK) {
_client.SendData("Nuevo Tablero Valido = ["
+ String.valueOf(_cantJugada) + "]\n");
_cantJugada++;
_client.SendData(" ".concat(aux.dump().concat("\n")));
}
}
}
break;
}
if (_debug) {
Log.i(TAG, "DEBUG");
Mat tmp = Mat.zeros(inputFrame.size(), CvType.CV_8UC4);
Mat matTMP = tmp.submat(Calibracion.getRectROI());
region.copyTo(matTMP);
return tmp;
}
return inputFrame;
}
public void destroy() {
if (_client != null) {
_client.Stop();
}
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/imgproc/BackgroundSupress.java deleted 100644 → 0
View file @ fdd60c21
package uy.edu.fing.chesstrack.modulovision.imgproc;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.video.BackgroundSubtractorMOG;
import org.opencv.video.BackgroundSubtractorMOG2;
import org.opencv.imgproc.*;
import android.graphics.SumPathEffect;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.util.Log;
public class BackgroundSupress implements ImgProcInterface {
private static final String TAG = "CHESSTRACK::BackgroundSupress";
private final Mat fgMaskMOG;
private final Mat fgMaskMOG2;
private final Mat morphKernel;
private final BackgroundSubtractorMOG pMOG;
private final BackgroundSubtractorMOG2 pMOG2;
private final List<MatOfPoint> contours;
public BackgroundSupress() {
super();
morphKernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3,3));
fgMaskMOG = new Mat(4,1,CvType.CV_8UC1);
fgMaskMOG2 = new Mat(4,1,CvType.CV_8UC1);
pMOG = new BackgroundSubtractorMOG(); //MOG approach
pMOG2 = new BackgroundSubtractorMOG2(); //MOG approach
Log.i(TAG, "at background supress constructor");
contours = new ArrayList<MatOfPoint>();
}
@Override
public Mat procesarImagen(Mat inputFrame) {
Log.i(TAG, "BackgroundS ");
Mat copy = new Mat(inputFrame.size(),CvType.CV_8UC3);
inputFrame.convertTo(copy, CvType.CV_8UC3);
Imgproc.cvtColor(inputFrame, copy, Imgproc.COLOR_BGRA2BGR);
pMOG.apply(copy, fgMaskMOG);
pMOG2.apply(copy, fgMaskMOG2,0);
Log.i(TAG, "Apply pMOG");
Imgproc.erode(fgMaskMOG2, fgMaskMOG2, morphKernel);
Log.i(TAG, "Apply erode");
Imgproc.threshold(fgMaskMOG2, fgMaskMOG2, 200, 255, Imgproc.THRESH_BINARY);
Log.i(TAG, "Apply threshold");
Imgproc.dilate(fgMaskMOG2, fgMaskMOG2, morphKernel);
Log.i(TAG, "Apply dilate");
Scalar suma = Core.sumElems(fgMaskMOG2);
Log.i(TAG, "SUMA = " + suma);
/*double maxArea = 0;
MatOfPoint largestContour = null;
Imgproc.findContours(fgMaskMOG2, contours, new Mat(), Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_TC89_L1);
for (MatOfPoint contour : contours) {
double area = Imgproc.contourArea(contour);
if (area > maxArea) {
maxArea = area;
largestContour = contour;
}
}
Log.i(TAG, "ESTABLE !!!" + maxArea);
if ((largestContour != null) && (maxArea > 10000)){
Log.i(TAG, "MANO !!!" + maxArea);
Rect boundingRect = Imgproc.boundingRect(largestContour);
ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // 200 is duration in ms
}*/
if (suma.val[0] > 100000){
Log.i(TAG, "MANO !!!");
Core.putText(fgMaskMOG2, "MANO !!!", new Point(50, 50),Core.FONT_HERSHEY_SIMPLEX, 0.8 , new Scalar(255,255,0));
// ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
// toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 200); // 200 is duration in ms
} else {
Log.i(TAG, "ESTABLE !!!");
Core.putText(fgMaskMOG2, "ESTABLE !!!", new Point(50, 50),Core.FONT_HERSHEY_SIMPLEX, 0.5 , new Scalar(255,255,0));
}
/*Imgproc.findContours(fgMaskMOG2, contours, new Mat(), Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_NONE);
for(int idx = 0; idx < contours.size(); idx++)
{
double area = Imgproc.contourArea(contours.get(idx));
Log.i(TAG, "CONTOUR = AREA: " + area);
if ((area > 15000) && (area < 70000)){
Log.i(TAG, "DRAW !!! : " + area);
Scalar color = new Scalar(255,127,127);
Rect r = Imgproc.boundingRect(contours.get(idx));
Log.i(TAG, "3 at backgroundS "+(fgMaskMOG2.type() == CvType.CV_8UC1));
Core.rectangle(fgMaskMOG2, r.tl(), r.br(), color, 2, 8, 0);
//Imgproc.drawContours(fgMaskMOG2, contours, idx, color);
}
}
contours.clear();*/
Log.i(TAG, "END Background Sss");
return fgMaskMOG2;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/imgproc/EcualizarImagen.java
View file @ a2136e1b
......@@ -3,17 +3,32 @@ package uy.edu.fing.chesstrack.modulovision.imgproc;
import org.opencv.core.Mat;
import org.opencv.imgproc.Imgproc;
import android.util.Log;
public class EcualizarImagen implements ImgProcInterface {
private static final String TAG = "CHESSTRACK::Ecualizar";
@Override
public Mat procesarImagen(Mat inputFrame) {
// TODO Auto-generated method stub
//cvEqualizeHist(src,dest)
Mat viewGray = new Mat();
Imgproc.cvtColor(inputFrame, viewGray, Imgproc.COLOR_BGR2GRAY);
Imgproc.equalizeHist(viewGray,viewGray);
//Imgproc.equalizeHist(inputFrame,inputFrame);
return viewGray;
}
//List<Mat> channels = new ArrayList<Mat>();
Mat img_hist_equalized = new Mat();
Log.i(TAG, "processing Frame - INI");
Imgproc.cvtColor(inputFrame, img_hist_equalized, Imgproc.COLOR_BGR2GRAY);
Imgproc.equalizeHist(img_hist_equalized, img_hist_equalized);
Imgproc.cvtColor(img_hist_equalized, inputFrame, Imgproc.COLOR_GRAY2BGR);
/*// ecualizar en cada canal
Core.split(inputFrame, channels); // split the image into channels
//Imgproc.equalizeHist(channels.get(0), channels.get(0));
Imgproc.equalizeHist(channels.get(1), channels.get(1));
//Imgproc.equalizeHist(channels.get(2), channels.get(2));
Core.merge(channels, inputFrame);
*/
Log.i(TAG, "processing Frame - FIN");
return img_hist_equalized;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/imgproc/Homografia.java
View file @ a2136e1b
......@@ -14,102 +14,105 @@ import android.util.Log;
public class Homografia implements ImgProcInterface {
private static final String TAG = "CHESSTRACK::Homografia";
private final Mat matrizTransformada;
private final Rect rectPOI;
private int media;
private int offset;
private final Mat _matrizTransformada;
private final Rect _rectROI;
private int _media;
private int _offset;
public Homografia() throws Exception {
super();
MatOfPoint2f vertices = Calibracion.getInstance().getVertices();
if (vertices != null){
Mat src = new Mat(4,1,CvType.CV_32FC2);
Mat dst = new Mat(4,1,CvType.CV_32FC2);
offset = (media/7);
Point p1, p2, p3, p4;
Point[] ret = getBestPoints(vertices, Calibracion.getInstance().getImagenCalibrada().size());
Log.i(TAG, "coso= " + ret);
Point[] ret = getBestPoints(vertices, Calibracion.getInstance().get_sizeFrame());
Log.i(TAG, "Best Points= " + ret.toString());
p1 = ret[0];
p2 = ret[1];
p3 = ret[2];
p4 = ret[3];
double d17 = Math.sqrt(Math.pow((p1.x- p2.x),2) + Math.pow((p1.y- p2.y),2));
double d749 = Math.sqrt(Math.pow((p2.x- p3.x),2) + Math.pow((p2.y- p3.y),2));
double d143 = Math.sqrt(Math.pow((p3.x- p4.x),2) + Math.pow((p3.y- p4.y),2));
double d4349 = Math.sqrt(Math.pow((p4.x- p1.x),2) + Math.pow((p4.y- p1.y),2));
media = (int) Math.floor( Math.round((d17+d749+d143+d4349)/4));
offset = 2*(media/7);
src.put(0,0 ,(int)p1.x,(int)p1.y, (int)p2.x,(int)p2.y, (int)p3.x,(int)p3.y, (int)p4.x,(int)p4.y);
dst.put(0,0, offset,offset ,offset+media,offset , offset+media,offset+media, offset,offset+media );
// EL offset es casi el tamaño de una celda
rectPOI = new Rect(new Point(0,0), new Point(2*offset+media,2*offset+media) );
Calibracion.getInstance().setRectPOI(rectPOI);
matrizTransformada = Imgproc.getPerspectiveTransform(src,dst);
}else{
// se obtienen las distancias de cada una de las aristas que determinan los vertices
// internos mas externos y se determina el promedio de esa medida
double d12 = Math.sqrt(Math.pow((p1.x- p2.x),2) + Math.pow((p1.y- p2.y),2));
double d23 = Math.sqrt(Math.pow((p2.x- p3.x),2) + Math.pow((p2.y- p3.y),2));
double d34 = Math.sqrt(Math.pow((p3.x- p4.x),2) + Math.pow((p3.y- p4.y),2));
double d14 = Math.sqrt(Math.pow((p4.x- p1.x),2) + Math.pow((p4.y- p1.y),2));
_media = (int) Math.floor( Math.round((d12+d23+d34+d14)/4));
// El offset es el tamaño de dos celdas (para abarcar el primer casillero y dejar un borde al tablero
_offset = 2*(_media/6);
Log.i(TAG, "media= " + _media);
Log.i(TAG, "offset= " + _offset);
src.put(0,0, (int)p1.x,(int)p1.y, (int)p2.x,(int)p2.y, (int)p3.x,(int)p3.y, (int)p4.x,(int)p4.y);
dst.put(0,0, _offset,_offset, _offset+_media,_offset, _offset+_media,_offset+_media, _offset,_offset+_media );
_rectROI = new Rect(new Point(0,0), new Point(2*_offset+_media,2*_offset+_media));
Calibracion.getInstance();
Calibracion.setRectROI(_rectROI);
Log.i(TAG, "rectROI size= " + _rectROI.size());
_matrizTransformada = Imgproc.getPerspectiveTransform(src,dst);
} else {
throw new Exception(TAG + "No se han calculado los vertices");
}
}
/**
* Hace homografia y recorta la imagen
*/
@Override
public Mat procesarImagen(Mat inputFrame) {
Log.i(TAG, "processing Frame - INI");
double x = inputFrame.size().width;
double y = inputFrame.size().height;
if (x < _rectROI.size().width){
x = _rectROI.size().width;
}
if (y < _rectROI.size().height){
y = _rectROI.size().height;
}
Mat aux = new Mat();
// hace la homografia con la matriz calculada en un ppio
Imgproc.warpPerspective(inputFrame,aux, _matrizTransformada, new Size(x,y));
Mat tmp = Mat.zeros(_rectROI.size(), CvType.CV_8UC4);
(aux.submat(_rectROI)).copyTo(tmp);
Imgproc.warpPerspective(inputFrame,inputFrame, matrizTransformada, inputFrame.size(),(Imgproc.INTER_LINEAR | Imgproc.CV_WARP_FILL_OUTLIERS));
Mat subMat = inputFrame.submat(rectPOI);
Mat tmp = Mat.zeros(inputFrame.size(), CvType.CV_8UC4);
Mat matTMP = tmp.submat(rectPOI);
subMat.copyTo(matTMP);
Log.i(TAG, "processing Frame - FIN");
return tmp;
}
private Point[] getBestPoints(MatOfPoint2f vertices, Size tamanio){
double d, best_dist;
Point[] ret = new Point[4];
Point[] vect = new Point[4];
double d, dx ,dy;
double betst_dist = Double.MAX_VALUE;
Point aux = new Point(0,0);
for(Point pt : vertices.toList()){
d = Math.sqrt(Math.pow((pt.x- aux.x),2) + Math.pow((pt.y- aux.y),2));
if (d < betst_dist){
betst_dist = d;
ret[0] = pt;
}
}
vect[0] = new Point(0,0);
vect[1] = new Point(tamanio.width,0);
vect[2] = new Point(tamanio.width,tamanio.height);
vect[3] = new Point(0,tamanio.height);
betst_dist = Double.MAX_VALUE;
aux = new Point(tamanio.width,0);
for(Point pt : vertices.toList()){
d = Math.sqrt(Math.pow((pt.x- aux.x),2) + Math.pow((pt.y- aux.y),2));
if (d < betst_dist){
betst_dist = d;
ret[1] = pt;
}
for (int i = 0; i < 4; i++){
Point aux = vect[i];
best_dist = Double.MAX_VALUE;
for(Point pt : vertices.toList()){
d = Math.sqrt(Math.pow((pt.x- aux.x),2) + Math.pow((pt.y- aux.y),2));
if (d < best_dist){
best_dist = d;
ret[i] = pt;
}
}
}
betst_dist = Double.MAX_VALUE;
aux = new Point(tamanio.width,tamanio.height);
for(Point pt : vertices.toList()){
d = Math.sqrt(Math.pow((pt.x- aux.x),2) + Math.pow((pt.y- aux.y),2));
if (d < betst_dist){
betst_dist = d;
ret[2] = pt;
}
}
betst_dist = Double.MAX_VALUE;
aux = new Point(0,tamanio.height);
for(Point pt : vertices.toList()){
d = Math.sqrt(Math.pow((pt.x- aux.x),2) + Math.pow((pt.y- aux.y),2));
if (d < betst_dist){
betst_dist = d;
ret[3] = pt;
}
}
return ret;
}
}
ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/imgproc/SustraccionDeFondo.java deleted 100644 → 0
View file @ fdd60c21
package uy.edu.fing.chesstrack.modulovision.imgproc;
import org.opencv.core.Mat;
import org.opencv.imgproc.Imgproc;
import org.opencv.video.BackgroundSubtractorMOG2;
public class SustraccionDeFondo implements ImgProcInterface {
private Mat fMaskMOG = null;
private final BackgroundSubtractorMOG2 pMOG;
private static final String TAG = "CHESSTRACK::SustraccionDeFondo";
public SustraccionDeFondo(){
pMOG = new BackgroundSubtractorMOG2();
//fMaskMOG = new Mat();
}
@Override
public Mat procesarImagen(Mat inputFrame) {
Imgproc.cvtColor(inputFrame, inputFrame, Imgproc.COLOR_RGBA2RGB);
fMaskMOG = new Mat(inputFrame.size(),inputFrame.channels());
pMOG.apply(inputFrame, fMaskMOG);
//Mat frame = inputFrame.submat(Calibracion.getInstance().getRectPOI());
//fMaskMOG = new Mat(frame.size(),frame.channels());
//pMOG.apply(frame, fMaskMOG);
//Imgproc.resize(inputFrame, frame, frame.size());
//Log.i(TAG, "Size frame= " + frame.size());
//Log.i(TAG, "Size fMaskMOG= " + fMaskMOG.size());
//Rect aux = Calibracion.getInstance().getRectPOI();
//frame.copyTo(frame,fMaskMOG);
//Mat subMat = inputFrame.submat(0,frame.rows(),0,frame.cols());
//frame.copyTo(subMat);
//Mat frame = new Mat();
//inputFrame.copyTo(frame,fMaskMOG);
return fMaskMOG;
}
}
cte-serv/cliente.java 0 → 100644
View file @ a2136e1b
import java.io.*;
import java.net.*;
class TCPClient {
public static void main(String argv[]) throws Exception
{
String sentence;
String modifiedSentence;
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
Socket clientSocket = new Socket("192.168.1.21", 5555);
DataOutputStream outToServer =
new DataOutputStream(clientSocket.getOutputStream());
BufferedReader inFromServer =
new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
sentence = inFromUser.readLine();
outToServer.writeBytes(sentence + '\n');
modifiedSentence = inFromServer.readLine();
System.out.println("FROM SERVER: " + modifiedSentence);
clientSocket.close();
}
}
cte-serv/server.java 0 → 100644
View file @ a2136e1b
import java.io.*;
import java.net.*;
class TCPServer {
public static void main(String argv[]) throws Exception
{
String clientSentence;
String capitalizedSentence;
ServerSocket welcomeSocket = new ServerSocket(5556);
Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient =
new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());
while(true) {
clientSentence = inFromClient.readLine();
//capitalizedSentence = clientSentence.toUpperCase() + '\n';
//outToClient.writeBytes(capitalizedSentence);
if (clientSentence != null){
System.out.println(clientSentence);
}
}
}
}
samples/CMakeLists.txt
View file @ a2136e1b
......@@ -3,3 +3,6 @@ project( SubsBackground )
find_package( OpenCV REQUIRED )
add_executable( SubsBackground SubsBackground.cpp )
target_link_libraries( SubsBackground ${OpenCV_LIBS} )
project( Corners )
add_executable( Corners Corners.cpp )
target_link_libraries( Corners ${OpenCV_LIBS} )
samples/Corners.cpp 0 → 100644
View file @ a2136e1b
#include <string>
#include <iostream>
#include <vector>
#include "opencv2/opencv.hpp"
using namespace std;
using namespace cv;
//----------------------------------------------------------
// MAIN
//----------------------------------------------------------
int main(int argc, char* argv[])
{
// src image
Mat src;
// dst image
Mat dst;
// Image loading
namedWindow("result");
namedWindow("src");
src=imread("image.png",0);
cv::cvtColor(src,dst,cv::COLOR_GRAY2BGR);
Mat corners;
cv::goodFeaturesToTrack(src,corners,100,0.01,20.0);
for(int i=0;i<corners.rows;++i)
{
circle(dst,cv::Point(corners.at<float>(i,0),corners.at<float>(i,1)),3,Scalar(255,0,0),-1,CV_AA);
}
imshow("src",src);
imshow("result",dst);
//----------------------------------------------------------
// Wait key press
//----------------------------------------------------------
while (waitKey(0) != 'q');
destroyAllWindows();
return 0;
}
samples/SubsBackground.cpp
View file @ a2136e1b
......@@ -66,7 +66,7 @@ int main(int argc, char* argv[])
//create GUI windows
namedWindow("Frame");
namedWindow("FG Mask MOG");
//namedWindow("FG Mask MOG");
namedWindow("FG Mask MOG 2");
//create Background Subtractor objects
......@@ -99,6 +99,10 @@ int main(int argc, char* argv[])
void processVideo(char* videoFilename) {
int estadoANTERIOR = 0;
int estadoACTUAL = 0;
int c = 0;
char buffer [15];
//create the capture object
VideoCapture capture(videoFilename);
if(!capture.isOpened()){
......@@ -142,7 +146,7 @@ void processVideo(char* videoFilename) {
// cerr << suma.val[0] << endl;
if (suma.val[0] > 1000000){
if (suma.val[0] > 1250000){
// estado oclusion
estadoANTERIOR = estadoACTUAL;
estadoACTUAL = 1;
......@@ -158,6 +162,12 @@ void processVideo(char* videoFilename) {
if (estadoANTERIOR == 3){
// estado estable
estadoACTUAL = 2;
imshow("ESTABLE", frame);
int b = sprintf (buffer, "tablero%d.png", c);
imwrite(buffer, frame);
c++;
pMOG= new BackgroundSubtractorMOG(); //MOG approach
pMOG2 = new BackgroundSubtractorMOG2(); //MOG2 approach
}
......@@ -184,7 +194,7 @@ void processVideo(char* videoFilename) {
//show the current frame and the fg masks
imshow("Frame", frame);
imshow("FG Mask MOG", fgMaskMOG);
// imshow("FG Mask MOG", fgMaskMOG);
imshow("FG Mask MOG 2", fgMaskMOG2);
//get the input from the keyboard
keyboard = waitKey( 30 );
......