NOMBRE: JEFFERSON PICHUCHO

CODIGO:

1) PRIMERA IMAGEN

#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;
using namespace std;

const String window_capture_name = "Video Original";

const String window_detection_name = "Objeto Detectado";
Mat frame, frame_HSV, frame_threshold,final_video;

int main(int argc, char* argv[] )

{

namedWindow(window_capture_name);
namedWindow(window_detection_name);
namedWindow(window_capture_name,0);
namedWindow(window_detection_name,WINDOW_NORMAL);
frame = imread( "D://Descargas//sudoku2.jpg", 1 );

// Convert from BGR to HSV colorspace

cvtColor(frame, frame_HSV, COLOR_BGR2HSV);

// Detect the object based on HSV Range Values

inRange(frame_HSV, Scalar(0, -150, 234), Scalar(20, 77, 255),

frame_threshold);
GaussianBlur(frame_threshold,frame_threshold,Size(3,3),0,0,0);
bitwise_not ( frame_threshold, frame_threshold );
// Muestra los

namedWindow(window_capture_name,WINDOW_AUTOSIZE);
namedWindow(window_detection_name,WINDOW_AUTOSIZE);
imshow(window_capture_name, frame);
imshow(window_detection_name, frame_threshold);

waitKey(0);

return 0;
}

SE APLICO 2 TIPOS DE FILTROS.

inRange(frame_HSV, Scalar(0, 24, 234), Scalar(20, 77, 255),
frame_threshold);

//PARA SEPARAR UN SOLO COLOR

GaussianBlur(frame_threshold,frame_threshold,Size(3,3),0,10,0);
//PARA INTENTAR ELIMINAR EL RUIDO

Imagen 2

Codigo
//-----------SEGUNDA PARTE-------------------------

// Mat src = imread("D:\\Opencv\\opencv343\\sources\\doc\\opencv-

logo2.png");
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <opencv2/core/core.hpp>
#include <iostream>
#include <stdio.h>
using namespace std;
using namespace cv;

Mat src,gris,dst;
int cont=0;
int maximo=0;
int video_mejorar=1;
int threshold_value=0;
int epsi=0;
double c=0;
Mat logaritmica_src,src_gray;
String tipo_de_mejoramiento = "---------";

void funcion_logaritmica()
{

//Funcion para sacar C el maximo

for (int i = 0; i < logaritmica_src.rows; i++)
 {

for (int j = 0; j < logaritmica_src.cols; j++)

{

int pixelvalue=(int)logaritmica_src.at<uchar>(i,j);
if(pixelvalue >= maximo)
{
maximo=pixelvalue;

c=255/(log10(1+maximo));
//Aplicando la funcion logartitmica
for (int i = 0; i < logaritmica_src.rows; i++)
{

for (int j = 0; j < logaritmica_src.cols; j++)

{

int pixelvalue=(int)logaritmica_src.at<uchar>(i,j);
epsi=255;
double epsi1=(double)epsi/255.0;
double conversion = c*log(1+(exp(epsi1)-1)*pixelvalue);
int conver= (int)conversion;

if(conver >= 255)

{
conver=255;
}
logaritmica_src.at<uchar>(i,j)= conver;
}
}
}

void funcion_exponencial()
{
for (int i = 0; i < logaritmica_src.rows; i++)
{

for (int j = 0; j < logaritmica_src.cols; j++)

{

int pixelvalue=(int)logaritmica_src.at<uchar>(i,j);
if(pixelvalue >= maximo)
{
maximo=pixelvalue;

c=255/(log10(1+maximo));
//Aplicando la funcion exponencial
 for (int i = 0; i < logaritmica_src.rows; i++)
{

for (int j = 0; j < logaritmica_src.cols; j++)

{

int pixelvalue=(int)logaritmica_src.at<uchar>(i,j);
double epsi1=epsi*0.05;
double potencia = pow((1+epsi1),pixelvalue);
double conversion = c*(potencia-1);

int conver= round(conversion);

logaritmica_src.at<uchar>(i,j)= conver;

}
}
}

int main()
{
cout <<endl ;
while(true)
{
Mat src = imread("D://Descargas//2unidad.jpg");
//cap>>src;

if( !src.data )
{ return -1; }
cvtColor(src,src,COLOR_BGR2GRAY);
src_gray=src.clone();
//PASAR POR EL FILTRO DE LOGRATIMICA
logaritmica_src=src.clone();

if (video_mejorar==0)
{
return -1;
}
if (video_mejorar==1)
{
funcion_logaritmica();
tipo_de_mejoramiento="Mejoramiento Logaritmico";
}

//creacion de trackbar

/// Create Trackbar to choose type of Threshold

createTrackbar( "thresh", "Threshold",
&threshold_value, 255);
createTrackbar( "epsilon", tipo_de_mejoramiento,
&epsi, 255);

//EL COMPUTO DE LOS DISTINTOS TIPOS DE SEGMENTACIO

threshold( logaritmica_src, dst, 240,255,THRESH_BINARY_INV );

// Filter kernel for detecting vertical edges

float ejemplo[3][3] = {{-1,-1,-1}, {0,0,0}, {1,1,1}};
 Mat ejemplo_bordes= Mat(3, 3, CV_32FC1, ejemplo);
// Apply filter
Mat img_ejemplo,img_ejemplo1,img_total_MAS;
filter2D(src_gray, img_ejemplo, -1, ejemplo_bordes);

// Filter kernel for detecting hortizontal edges

float ejemplo1[3][3] = {{-1,0,1}, {-1,0,1}, {-1,0,1}};
Mat ejemplo_bordes1= Mat(3, 3, CV_32FC1, ejemplo1);
// Apply filter
filter2D(src_gray, img_ejemplo1, -1, ejemplo_bordes1);

img_total_MAS=img_ejemplo+img_ejemplo1+dst;
Mat element = getStructuringElement( MORPH_CROSS,
Size( 2,2 ),
Point( -1, -1 ) );
dilate(img_total_MAS,img_total_MAS,element);
/// Display
imshow("Original", src);
imshow("imagen grises", src_gray);
imshow(tipo_de_mejoramiento, logaritmica_src);
imshow("Threshold", dst);
imshow("FINAL", img_total_MAS);

if (waitKey(1)==27)
return 0;
}

Anexos