se agrega la calibracion y un intento de homografia

ProyectoAndroid/ChessTrack/res/layout/chess_track_layout

@@ -4,6 +4,13 @@
     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" />
+
+
     <org.opencv.android.JavaCameraView
         android:layout_width="fill_parent"
         android:layout_height="fill_parent"

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

@@ -9,11 +9,17 @@ import org.opencv.android.OpenCVLoader;
 import org.opencv.core.Mat;
 
 import uy.edu.fing.chesstrack.modulovision.Adquisicion;
+import uy.edu.fing.chesstrack.modulovision.Calibracion;
 import android.app.Activity;
+import android.media.AudioManager;
+import android.media.ToneGenerator;
 import android.os.Bundle;
 import android.util.Log;
 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 {
 
@@ -22,6 +28,13 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 	private CameraBridgeViewBase mOpenCvCameraView;
 
 	private Adquisicion adq;
+	private Calibracion calibrar;
+	private Button btnCalibrar;
+
+	//TODO es chancho pero ver luego
+	private Mat frame;
+	private boolean isUsed;
+	private  boolean isCalibrada ;
 
 	private final BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
 		@Override
@@ -57,9 +70,45 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 		mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.chess_track_layout);
 		mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
 		mOpenCvCameraView.setCvCameraViewListener(this);
-		adq = new Adquisicion();
+
+		calibrar = new Calibracion();
+
+
+
+		isUsed = false;
+		isCalibrada =false;
+		addListenerOnButton();
+	}
+
+	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 (calibrar.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
+
+						adq = new Adquisicion(calibrar);
+					}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;
+			}
+
+		});
+
 	}
 
+
 	@Override
 	public void onPause()
 	{
@@ -90,7 +139,24 @@ public class ChessTrackActivity extends Activity implements CvCameraViewListener
 	@Override
 	public Mat onCameraFrame(Mat inputFrame) {
 		// TODO Auto-generated method stub
-		return adq.processFrame(inputFrame);
+		//return adq.processFrame(inputFrame);
+		if (!isUsed){
+			frame = inputFrame;
+		}
+
+		if(isCalibrada){
+
+			/*
+			Core.circle(inputFrame, calibrar.getVertices().toList().get(0), 10, new Scalar(0,0 , 255, 255),-25);
+			Core.circle(inputFrame, calibrar.getVertices().toList().get(6), 10, new Scalar(0,255 , 255, 0),-25);
+			Core.circle(inputFrame, calibrar.getVertices().toList().get(42), 10, new Scalar(0,0 , 0, 255),-25)
+			Core.circle(inputFrame, calibrar.getVertices().toList().get(48), 10, new Scalar(0,0 , 128, 255),-25);
+			return inputFrame ;
+			 */
+			return adq.processFrame(inputFrame);
+		}
+
+		return inputFrame;
 	}
 
 }

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

@@ -7,7 +7,7 @@ import java.util.List;
 
 import org.opencv.core.Mat;
 
-import uy.edu.fing.chesstrack.modulovision.imgproc.EcualizarImagen;
+import uy.edu.fing.chesstrack.modulovision.imgproc.Homografia;
 import uy.edu.fing.chesstrack.modulovision.imgproc.ImgProcInterface;
 import android.util.Log;
 
@@ -19,11 +19,12 @@ public class Adquisicion   {
 	private static final String TAG = "CHESSTRACK::Adquisicion";
 
 
-	public Adquisicion() {
+	public Adquisicion(Calibracion cal) {
 		super();
 		Log.i(TAG, "Cargado....");
 		listProc = new ArrayList<ImgProcInterface>();
-		listProc.add( new EcualizarImagen());
+		//listProc.add( new EcualizarImagen());
+		listProc.add( new Homografia(cal.getVertices()));
 	}
 
 	/**

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.Size;
+
+import android.util.Log;
+
+
+public class Calibracion  {
+	private Mat imagenCalibrada;
+	private Mat imagenOriginal;
+	private MatOfPoint2f vertices;
+	private static final String TAG = "CHESSTRACK::Calibracion";
+
+
+	public boolean calibrar(Mat img){
+		Log.i(TAG, "INI calibrando");
+		boolean OK = false;
+		imagenOriginal = img;
+		imagenCalibrada = img;
+		Size patternSize = new Size(7,7);
+		MatOfPoint2f corners = new MatOfPoint2f();
+		boolean ret = Calib3d.findChessboardCorners(imagenOriginal, 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;
+			//
+			//			for(Point p : vertices.toList()){
+			//				Log.i(TAG, "Encontro = " + Math.round(p.x) + " " + Math.round(p.y));
+			//			}
+		}
+		OK = ret;
+
+
+
+		Log.i(TAG, "FIN calibrando = " + ret);
+		return OK;
+	}
+
+
+	public Mat getImagenCalibrada() {
+		return imagenCalibrada;
+	}
+
+
+	public void setImagenCalibrada(Mat imagenCalibrada) {
+		this.imagenCalibrada = imagenCalibrada;
+	}
+
+
+	public MatOfPoint2f getVertices() {
+		return vertices;
+	}
+
+
+	public void setVertices(MatOfPoint2f vertices) {
+		this.vertices = vertices;
+	}
+
+
+
+
+
+}

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.imgproc.Imgproc;
+
+public class Homografia implements ImgProcInterface {
+
+
+	private final   Mat matrizTransformada;
+
+	public Homografia(MatOfPoint2f vertices) {
+		super();
+		int offset = 48*2;
+		int media = 48*6;
+		Mat src = new Mat(4,1,CvType.CV_32FC2);
+		Mat dst = new Mat(4,1,CvType.CV_32FC2);
+		Point p1,p2,p3,p4;
+		p1 = vertices.toList().get(0);
+		p2 = vertices.toList().get(6);
+		p3 = vertices.toList().get(42);
+		p4 = vertices.toList().get(48);
+		src.put((int)p1.y,(int)p1.x, (int)p2.y,(int)p2.x, (int)p4.y,(int)p4.x, (int)p3.y,(int)p3.x);
+		dst.put( offset,offset ,offset+media,offset , offset,offset+media , offset+media,offset+media );
+
+		matrizTransformada = Imgproc.getPerspectiveTransform(src,dst);
+	}
+
+
+
+	@Override
+	public Mat procesarImagen(Mat inputFrame) {
+		Mat out = inputFrame.clone();
+		Imgproc.warpPerspective(inputFrame,out, matrizTransformada, out.size());
+		return inputFrame;
+	}
+
+
+}