.gitignore

@@ -2,7 +2,8 @@
 *~
 
 # Directories #
-#ProyectoAndroid/ChessTrack/bin
+ProyectoAndroid/ChessTrack/bin/*
+ProyectoAndroid/ChessTrack/gen/*
 
 #java specific
 *.class

ProyectoAndroid/ChessTrack/AndroidManifest.xml

@@ -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

-<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/res/layout/chess_track_layout → ProyectoAndroid/ChessTrack/res/layout/chess_track_layout.xml

 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     xmlns:opencv="http://schemas.android.com/apk/res-auto"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent" >
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+   >
 
     <org.opencv.android.JavaCameraView
         android:layout_width="fill_parent"

ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/ChessTrackActivity.java

 package uy.edu.fing.chesstrack;
 
-
 import org.opencv.android.BaseLoaderCallback;
 import org.opencv.android.CameraBridgeViewBase;
-import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
 import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.android.JavaCameraView;
 import org.opencv.android.LoaderCallbackInterface;
 import org.opencv.android.OpenCVLoader;
 import org.opencv.core.Mat;
 
+import uy.edu.fing.chesstrack.modulovision.Manager;
 import android.app.Activity;
+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 Manager _manager;
+	private MenuItem _mItemCalibrar;
+	private MenuItem _mItemServer;
+	private int _estado;
 
-	private CameraBridgeViewBase mOpenCvCameraView;
+	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 = (CameraBridgeViewBase) 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();
+	}
+
+	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());
+				}
+			}
+		});
+
+		alert.show();
+	}
+
+	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("Calibrar..");
+		_mItemServer = menu.add("Conectar Server");
+		return true;
 	}
 
 	@Override
-	public void onPause()
-	{
+	public boolean onOptionsItemSelected(MenuItem item) {
+		Log.i(TAG, "Menu Item selected " + item);
+		if (item == _mItemCalibrar) {
+			if (_estado == IDLE) {
+				_estado = CALIBRAR;
+			}
+		} else if (item == _mItemServer) {
+			getServerIp();
+		}
+		return true;
+	}
+
+	@Override
+	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();
 		}
 	}
 
@@ -82,14 +187,26 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 	public void onCameraViewStopped() {
 	}
 
-	public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
-		return inputFrame.rgba();
-	}
-
 	@Override
 	public Mat onCameraFrame(Mat inputFrame) {
-		// TODO Auto-generated method stub
-		return null;
+		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

+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

+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

+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 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;
+
+	public Modelador() {
+		tablero = Mat.zeros(new Size(8, 8), CvType.CV_8UC1);
+		escaques = new Mat[CANT_FILAS][CANT_FILAS];
+
+	}
+
+	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 + 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) + 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 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++) {
+				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);
+				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

 package uy.edu.fing.chesstrack.modulovision;
 
+import java.util.ArrayList;
+import java.util.List;
 
-public class Adquisicion {
+import org.opencv.core.Mat;
 
+import uy.edu.fing.chesstrack.modulovision.imgproc.Homografia;
+import uy.edu.fing.chesstrack.modulovision.imgproc.ImgProcInterface;
+import android.util.Log;
+
+public class Adquisicion   {
+	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());
+	}
+
+	/**
+	 * PRocesa el frame pasado por parametro
+	 * @param inputPicture
+	 * @return
+	 * ver http://dsp.stackexchange.com/questions/2805/how-does-opencv-find-chessboard-corners
+	 * http://www.cvg.ethz.ch/teaching/2012fall/cvl/Tutorial-OpenCV.pdf
+	 */
+	public synchronized Mat processFrame(Mat inputPicture) {
+		Log.i(TAG, "processFrame inicia");
+		Mat tempImg = inputPicture;
+		for (ImgProcInterface proc: _listProc){
+			tempImg = proc.procesarImagen(tempImg);
+		}
+		return tempImg;
+	}
 }

ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/Calibracion.java

+package uy.edu.fing.chesstrack.modulovision;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Rect;
+import org.opencv.core.Size;
+
+import android.util.Log;
+
+public class Calibracion {
+	private static final String TAG = "CHESSTRACK::Calibracion";
+
+	private Size _sizeFrame = null;
+	private MatOfPoint2f _vertices = null;
+	private static Rect _rectROI = null;
+
+	private static Calibracion _instance;
+
+	protected Calibracion() {
+
+	}
+
+	public static Calibracion getInstance() {
+		if (_instance == null) {
+			_instance = new Calibracion();
+		}
+		return _instance;
+	}
+
+	public boolean calibrar(Mat img) {
+		Log.i(TAG, "INI calibrando");
+
+		Size patternSize = new Size(7, 7);
+		MatOfPoint2f corners = new MatOfPoint2f();
+		boolean ret = Calib3d.findChessboardCorners(img, patternSize, corners);
+		if (ret) {
+			Log.i(TAG, "Encontro = " + corners.total());
+			// Calib3d.drawChessboardCorners(img, patternSize, corners, ret);
+			// only for debug
+			_vertices = corners;
+			_sizeFrame = img.size();
+		}
+		Log.i(TAG, "FIN calibrando = " + ret);
+		return ret;
+	}
+
+	public Size get_sizeFrame() {
+		return _sizeFrame;
+	}
+
+	public void set_sizeFrame(Size _sizeFrame) {
+		this._sizeFrame = _sizeFrame;
+	}
+
+	public MatOfPoint2f getVertices() {
+		return _vertices;
+	}
+
+	public void setVertices(MatOfPoint2f vertices) {
+		this._vertices = vertices;
+	}
+
+	public static Rect getRectROI() {
+		return _rectROI;
+	}
+
+	public static void setRectROI(Rect rectROI) {
+		Calibracion._rectROI = rectROI;
+	}
+}

ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/DetectorOclusion.java

+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

+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/EcualizarImagen.java

+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) {
+		//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

+package uy.edu.fing.chesstrack.modulovision.imgproc;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+
+import uy.edu.fing.chesstrack.modulovision.Calibracion;
+import android.util.Log;
+
+public class Homografia implements ImgProcInterface {
+
+	private static final String TAG = "CHESSTRACK::Homografia";
+
+	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);
+			
+			Point p1, p2, p3, p4;
+			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];
+			
+			// 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);
+
+		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];
+
+		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);
+
+		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;
+				}
+			}			
+		}
+
+		return ret;
+	}
+}

ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulovision/imgproc/ImgProcInterface.java

+package uy.edu.fing.chesstrack.modulovision.imgproc;
+
+import org.opencv.core.Mat;
+
+/*
+ * Las clases para procesar las imagenes deben de implementar
+ * esta interface y recibiran una imagen que puede haber sido
+ * por otra clase en un paso previo
+ */
+public interface ImgProcInterface {
+	abstract Mat procesarImagen(Mat inputFrame);
+}

cte-serv/cliente.java

+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

+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);
+           }
+        } 
+    } 
+} 
+ 

matlab_prot/untitled.m

+clc
+close all
+
+% Connect to a camera
+%
+camera = cv.VideoCapture(1);
+pause(4);
+% get Frame
+frame = camera.read;
+%}
+%frame = imread('dd.png');
+if (size(frame,1) ~= 0)
+
+% save frame
+imwrite(frame, 'frame0.png');
+% show frame
+figure,
+imshow(frame);
+
+patternSize = [7,7];
+corners = cv.findChessboardCorners(frame, patternSize);
+wind = cv.drawChessboardCorners(frame, patternSize, corners);
+
+% show frame
+figure,
+imshow(wind);
+% save frame
+imwrite(wind, 'frame0esq.png');
+
+% muevo corners a otra estructura de datos
+sizeV = size(corners,2);
+esquinas = zeros(sizeV,2);
+for i=1:sizeV
+    esquinas(i,1) = corners{i}(1);
+    esquinas(i,2) = corners{i}(2);
+end
+
+% muestro de a una en orden qe las veo
+%{
+e = round(esquinas);
+orden = wind;
+for i=1:sizeV
+    orden(e(i,2)-5:e(i,2)+5,e(i,1)-5:e(i,1)+5,:) = 0;
+    figure,
+    imshow(orden); 
+end
+
+%}
+
+% muestro de a una en orden qe las veo
+%{
+e = round(esquinas);
+externas = wind;
+externas(e(1,2)-5:e(1,2)+5,e(1,1)-5:e(1,1)+5,:) = 0;
+externas(e(7,2)-5:e(7,2)+5,e(7,1)-5:e(7,1)+5,:) = 0;
+externas(e(43,2)-5:e(43,2)+5,e(43,1)-5:e(43,1)+5,:) = 0;
+externas(e(49,2)-5:e(49,2)+5,e(49,1)-5:e(49,1)+5,:) = 0;
+figure,
+imshow(externas);
+%}
+
+e = round(esquinas);
+% distancias, promedio, media
+%{
+d17 = sqrt((e(1,1)-e(7,1))^2 + (e(1,2)-e(7,2))^2);
+d749 = sqrt((e(7,1)-e(49,1))^2 + (e(7,2)-e(49,2))^2);
+d143 = sqrt((e(1,1)-e(43,1))^2 + (e(1,2)-e(43,2))^2);
+d4349 = sqrt((e(43,1)-e(49,1))^2 + (e(43,2)-e(49,2))^2);
+media = round(mean([d17,d749,d143,d4349]));
+offset = 2*(media/7);
+%}
+offset = 48*2;
+media = 48*6;
+a = [e(1,:);e(7,:);e(43,:);e(49,:)];
+b = [ offset,offset ; offset+media,offset ; offset,offset+media ; offset+media,offset+media ];
+
+matrizTransformada = cv.getPerspectiveTransform(a,b);
+
+transformada = cv.warpPerspective(frame, matrizTransformada,'DSize', [480,480]);
+figure,
+imshow(transformada);
+imwrite(transformada, 'framehomogra.png');
+
+% muestro de a una en orden qe las veo
+%{
+e = 20:20:180;
+cuadricula = transformada;
+tablero = zeros(81,2);
+for i=1:9
+    for j=1:9
+        cuadricula(e(i):e(i),e(j):e(j),:) = 0;
+        cuadricula(e(i):e(i),e(j):e(j),3) = 255;
+        tablero((i-1)*9+j,1) = e(i);
+        tablero((i-1)*9+j,2) = e(j);
+    end
+end
+
+figure,
+imshow(cuadricula);
+imwrite(cuadricula, 'cuadricula'+i+'.png');
+
+%}
+%{
+outputString = sprintf('I am %d years old', n)
+t2 = dlmread('tablero2.txt');
+dlmwrite('tablero2.txt', transformada);
+%}
+
+%{
+edges = cv.Canny(transformada, 60);
+figure,
+imshow(edges);
+imwrite(edges, 'edges.png');
+%}
+
+end
+%%%%%%%%%%%% ----- FIN ----- %%%%%%%%%%%%
\ No newline at end of file

samples/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+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} )