agrego modelador, saco boton y pongo menu, cambio de extencion layout

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" >
-
-    <Button
-        android:id="@+id/btn_calibrar"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="calibrar" />
-
+    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

@@ -8,6 +8,7 @@ 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 android.app.Activity;
@@ -15,11 +16,10 @@ import android.media.AudioManager;
 import android.media.ToneGenerator;
 import android.os.Bundle;
 import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
 import android.view.SurfaceView;
-import android.view.View;
-import android.view.View.OnClickListener;
 import android.view.WindowManager;
-import android.widget.Button;
 
 public class ChessTrackActivity extends Activity implements CvCameraViewListener {
 
@@ -29,8 +29,8 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 
 	private Adquisicion adq;
 	private Calibracion calibrar;
-	private Button btnCalibrar;
 
+	private MenuItem mItemCalibrar;
 	//TODO es chancho pero ver luego
 	private Mat frame;
 	private boolean isUsed;
@@ -70,11 +70,12 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 		mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.chess_track_layout);
 		mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
 		mOpenCvCameraView.setCvCameraViewListener(this);
+		Modelador.getInstance();
 		try {
 
 			isUsed = false;
 			isCalibrada =false;
-			addListenerOnButton();
+
 		} catch (Exception e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
@@ -82,37 +83,42 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 
 	}
 
-	public void addListenerOnButton() {
-
-		btnCalibrar = (Button) findViewById(R.id.btn_calibrar);
-
-		btnCalibrar.setOnClickListener(new OnClickListener() {
-
-			@Override
-			public void onClick(View arg0) {
-				isUsed = true;
-				if(frame!=null){
-					if (Calibracion.getInstance().calibrar(frame)){
-						isCalibrada = true;
-						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();
-						}
-					}else{
-						ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 50);
-						toneG.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 700); // 200 is duration in ms
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		Log.i(TAG, "called onCreateOptionsMenu");
+		mItemCalibrar = menu.add("Show/hide tile numbers");
+
+		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
 				}
-				isUsed = false;
 			}
+			isUsed = false;
+		}
+		return true;
+	}
 
-		});
 
-	}
 
 
 	@Override
@@ -152,7 +158,11 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 		if(isCalibrada){
 
 			Log.i(TAG, "calibrada");
-			return adq.processFrame(inputFrame);
+
+			inputFrame = adq.processFrame(inputFrame);
+			Modelador.getInstance().dividirTablero(inputFrame);
+			return Modelador.getInstance().dibujarEscaque(2, 3);
+			///return inputFrame;
 		}
 
 		return inputFrame;

ProyectoAndroid/ChessTrack/src/uy/edu/fing/chesstrack/modulomodelador/Modelador.java

+package uy.edu.fing.chesstrack.modulomodelador;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+
+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;
+	// se cuentan de arrib a abajo y de izquierda a derecha
+	private final Mat[][] escaques;
+	private static Modelador instance;
+
+
+	private Modelador(){
+		tablero = new int[CANT_FILAS][CANT_FILAS];
+		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();
+		// 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) );
+		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);
+			}
+		}
+	}
+
+	public Mat dibujarEscaque(int i, int j){
+		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);
+		return tmp;
+	}
+
+}

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

@@ -9,7 +9,6 @@ import org.opencv.core.Mat;
 
 import uy.edu.fing.chesstrack.modulovision.imgproc.Homografia;
 import uy.edu.fing.chesstrack.modulovision.imgproc.ImgProcInterface;
-import uy.edu.fing.chesstrack.modulovision.imgproc.SustraccionDeFondo;
 import android.util.Log;
 
 
@@ -27,7 +26,9 @@ public class Adquisicion   {
 
 		listProc.add( new Homografia());
 		//listProc.add( new EcualizarImagen());
-		listProc.add( new SustraccionDeFondo());
+		//listProc.add( new SustraccionDeFondo());
+		//listProc.add( new BackgroundSupress());
+
 	}
 
 	/**

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

@@ -5,17 +5,18 @@ 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 rectPOI;
-
+	private int media;
+	private int offset;
 	public Homografia() throws Exception {
 		super();
 		MatOfPoint2f vertices = Calibracion.getInstance().getVertices();
@@ -32,15 +33,33 @@ public class Homografia implements ImgProcInterface {
 			double d143 = Math.sqrt(Math.pow((p1.x- p3.x),2) + Math.pow((p1.y- p3.y),2));
 			double d4349 = Math.sqrt(Math.pow((p3.x- p4.x),2) + Math.pow((p3.y- p4.y),2));
 
-			int media = (int) Math.floor( Math.round((d17+d749+d143+d4349)/4));
-			int offset = 2*(media/7);
+			media = (int) Math.floor( Math.round((d17+d749+d143+d4349)/4));
+			offset = 2*(media/7);
+			//			offset = (media/7);
+			//			Point p1, p2, p3, p4;
+			//			Point[] ret = getBestPoints(vertices, Calibracion.getInstance().getImagenCalibrada().size());
+			//			Log.i(TAG, "coso= " + ret);
+			//			p1 = ret[0];
+			//			p2 = ret[1];
+			//			p3 = ret[2];
+			//			p4 = ret[3];
+			//
+			//			double corner_width = Math.abs(Math.sqrt(Math.pow((p1.x- p2.x),2) + Math.pow((p1.y- p2.y),2))/7);
+			//			double corner_height = corner_width;
+			//
+			//			double real_left_x = 0 + corner_width;
+			//			double real_right_x = 0 + 9 * corner_width;
+			//			double real_top_y = 0 + corner_height;
+			//			double real_bottom_y = 0 + 9 * corner_height;
 			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, real_left_x ,real_top_y ,real_right_x ,real_top_y, real_right_x,real_bottom_y, real_left_x,real_bottom_y );
 			dst.put(0,0, offset,offset ,offset+media,offset , offset,offset+media , offset+media,offset+media );
-			Log.i(TAG, "offset= " + offset);
-			Log.i(TAG, "media = " + media);
+			//			Log.i(TAG, "corner_width= " + corner_width);
+			//			Log.i(TAG, "corner_height = " + corner_height);
 
 			// 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));
+			//rectPOI = new Rect(new Point(0,0), new Point(9*corner_width,9*corner_height) );
+			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{
@@ -53,14 +72,74 @@ public class Homografia implements ImgProcInterface {
 	@Override
 	public Mat procesarImagen(Mat inputFrame) {
 
-		Imgproc.warpPerspective(inputFrame,inputFrame, matrizTransformada, inputFrame.size());
+		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);
 		return tmp;
 
+		//Core.circle(inputFrame,  new Point(offset,offset), offset, new Scalar(0,0 , 255, 255));
+		//Core.circle(inputFrame,  new Point(offset,offset), 5, new Scalar(0,255, 0, 255));
+		//		return inputFrame;
 	}
 
+	private Point[] getBestPoints(MatOfPoint2f vertices, Size tamanio){
+		Point[] ret = new Point[4];
+
+		double d, dx ,dy;
+		double betst_dist = Double.MAX_VALUE;
+		Point aux = new Point(0,0);
+		for(Point pt : vertices.toList()){
+			//			dx = pt.x-aux.x;
+			//			dy= pt.y -aux.y;
+			//			d = dx*dx + dy*dy;
+			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;
+			}
+		}
+
+		betst_dist = Double.MAX_VALUE;
+		aux = new Point(tamanio.width,0);
+		for(Point pt : vertices.toList()){
+			//			dx = pt.x - aux.x;
+			//			dy= pt.y -aux.y;
+			//			d = dx*dx + dy*dy;
+			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;
+			}
+		}
+
+		betst_dist = Double.MAX_VALUE;
+		aux = new Point(tamanio.width,tamanio.height);
+		for(Point pt : vertices.toList()){
+			//			dx = pt.x-aux.x;
+			//			dy= pt.y -aux.y;
+			//			d = dx*dx + dy*dy;
+			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()){
+			//			dx = pt.x-aux.x;
+			//			dy= pt.y -aux.y;
+			//			d = dx*dx + dy*dy;
+			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;
+	}
 
 }