#------------------------------------------------- --------------#
getwd() # comprobar la ubicación del archivo
library(EBImage) # librería tratamiento im
help(EBImage) # para obtener ayuda sobre el paquete

#------------------------------------------------- --------------#
## creación de imágenes en escala de grises - ruido uniforme ##
altura       <- 333   
anchura       <- 111
plans         <- 1  # gris : 1 plano de color
dimension     <- c(altura , anchura , plans)

                 # creación de los píxeles
num            <- altura * anchura * plans
data          <- array(runif(num), 
                       dim =dimension)

                 # creación de la imagen
im <- Image(data,
           dim = dimension, 
           colormode='Grayscale')
display(im)      # visualización en elbrowser

display(resize(im, 2*altura, 2*anchura),  # escala
        method = "raster",                 # visualización en R
        all = TRUE)
print(im)        # características im

#---------------------------------------------------------------#
## ídem, pero creación imagen color - ruido gaussien          ##

altura       <- 200   
anchura       <- 111
plans         <- 3     # número de planos de color
dimension     <- c(altura , anchura , plans)

# creación de los píxeles
num            <- altura * anchura * plans
data          <- array(rnorm(num,mean = 0.5, sd =0.15), 
                       dim =dimension)

# creación de la imagen
im <- Image(data,
           dim = dimension, 
           colormode='Color')

# visualización
display(resize(im, 2*altura, 2*anchura),    # escala
        method = "raster",                   # visualización en R
        all = TRUE)
print(im)        # características im
hist(im)

#---------------------------------------------------------------#
## ecritura de las imágenes en disco                              ##
writeImage(im, 'test.tiff')  # copia de seguridad im sin compresión
writeImage(im, 'test.jpeg' ,quality=80)  # copia de seguridad im jpg

#---------------------------------------------------------------#
## lectura de una imagen en disco                              ##
im <- readImage("mika.jpg")
print(im)
dim(im)
altura <- dim(im)[1]
anchura <- dim(im)[2]
plans   <- dim(im)[3]
dimension     <- c(altura , anchura , plans)
display(resize(im, 1.5*altura, 1.5*anchura), # escala
        method = "raster",                    # visualización en R
        all = TRUE)

data <- imageData(im) # obtenemos un array compatible con cualquier programa
str(data) # dimensión y primeros valores de datos
#------------------------------------------------- --------------#
## función mostrar imagen de comparación antes vs después ##
## Implementación naif, si la imagen 2 no es del mismo tamaño, solo ##
## este se muestra ##

f_display2 <- function (ima, imb) {
  imf <- imb                         # muestra imb por defecto
  altura <- dim(imb)[1]
  anchura <- dim(imb)[2]
  
  combinar <- (dim(ima)[1] == altura) &  # misma altura ?
              (dim(ima)[2] == anchura)    # misma anchura ?
  if (combinar) {imf <- combine(ima,imb)} # si sí combina

  ## fabricación de una imagen con  2 frames y visualización

  display(resize(imf, 2*altura, 2*anchura), # escala = 2
          method = "raster",                 # visualización en R
          all = TRUE)
  }


#---------------------------------------------------------------#
## manipular  el color - simplemente                          ##

## luminosidad : + o -
im <- readImage("mika.jpg")
im1 <- im - 0.3
f_display2(im,im1)


altura   <- dim(im)[1]
anchura   <- dim(im)[2]
plans     <- dim(im)[3]
dimension <- c(altura , anchura , plans)

sum(im < 1e6 )/3     # num de píxeles
altura*anchura      # ídem
sum(im < 0.3 )/3     # num píxeles sombras a sombrear 
sum(im1 < 0  )/3     # num píxeles sombreados

                                  # creación imagen blanca
data  <- array(1, dim =dimension) # 3*1 = blanca
im_blanca <- Image(data,
              dim = dimension,    # a las dimensiones de mika
              colormode='Color')
im_negra   <- im_blanca - 1      # creación imagen negra
                                  # inútil pero ejemplo
im2 <-im_blanca
im2[which(  im < 0.3 )] <- 0

f_display2(im,im2)

## luminositdad : + o -
im2 <- im1 + 0.3
f_display2(im,im2)

## contraste : *
im <- readImage("aix.jpg")
im1 <- im * 1.5
f_display2(im,im1)

## corrección gama : ^
im <- readImage("jardin.jpg")
im1 <- im ^ 2
f_display2(im,im1)


#---------------------------------------------------------------#
## manipular  la superficie - simplemente                          ##

## división/cropping, evidentemente:
im <- readImage("gatito.jpg")
dim(im)
altura <- dim(im)[1]
anchura <- dim(im)[2]
plans   <- dim(im)[3]
im1 <- im[1:200, 1:200, ]  # observelo, para tener las 3 dimensiones!
f_display2(im,resize(im1,altura,anchura))


## división/cropping, sin el primer plano de color:
im1 <-im[20:90, 20:50, 2:3 ]
f_display2(im,im1)

#---------------------------------------------------------------#
## manipulaer  la geometría - simplemente                        ##

## tamaño
im1 <- resize(im, 500) 
str(im1)
f_display2(im,im1)

## inversión
im <- readImage("gaviotas.jpg")
im1 <- flip(im)
f_display2(im,im1)

im <- readImage("laguna.jpg")
im1 = flop(im)
f_display2(im,im1)


## translación
im1 <- translate(im, c(100, 100))
f_display2(im,im1)
## rotation
im <- readImage("pajaro.jpg")
im1 <- rotate(im,45)
f_display2(im,im1)



#transformación afin cualquiera  
im <- readImage("rosas.jpg")
trans_afin <- matrix(c(
                         0.5,   0.1, 
                         0  ,  -0.3, 
                         0.5,   3
                         ), 
                         nrow=3)

im1 <- afin(im, trans_afin) 
f_display2(im,im1)

#---------------------------------------------------------------#
## análisis de la imagen  después de la ecualización                       ##

hist(im)  # análisis de los colores de la imagen
im1= equalize(im)
hist(im1)
f_display2(im,im1)

#---------------------------------------------------------------#
## filtro medio y seguidamente eliminar las intensidades de pixel    ##

im2 <- medianFilter(im1, 1.1)  > 0.6
f_display2(im1,im2)

#---------------------------------------------------------------#
display(5000*makeBrush(101, shape='Gaussian', sigma=20))
dilate(im,makeBrush(101, shape='Gaussian', sigma=20))

#---------------------------------------------------------------#
#---------------------------------------------------------------#
## lsh                                                         ##
#---------------------------------------------------------------#
library(lhs)

set.seed(11)
n <- 100 # número de observaciones
k <- 4 # número características
X_ <- optimumLHS(n, k) # dist max LHS uniforme
X <- matrix(0,nrow = n, ncol = k ) # para recibir al transformador
X[,1] <- qnorm(X_[,1]) # Transformada gaussiana
X[,2] <- qexp(X_[,2]) # exponencial
X[,3] <- qpois(X_[,3],lambda = 1) # poisson
X[,4] <- X_[,4] # sin cambios (uniforme)

require(ggplot2)
require(GGally)
df <- data.frame(X)
names(df) <- c("X1_Norm", "X2_Exp", "X3_Pois_1", "X4_unif")
p1 <- ggpairs(df[,c(1,2,3,4)], # elección de variables
              alfa = 1/2) # transparencia

p1<- p1 + theme(panel.background = # ¡es más bonito!
                  element_rect(colour = "pink"))

p1<- p1 + theme(text=element_text(size=14)) # tamaño caracteres
p1                                          # visualización

#---------------------------------------------------------------#
# kriging                                                       #
require(DiceKriging)
                                    # una función desconocida
y <- abs((10*df[,1])+7*(df[,2])+3*sin(df[,3])+sin(df[,4])) 
df.train <- df[1:70,]     
y.train  <-  y[1:70]
df.test  <- df[71:100,]
y.test   <-  y[71:100]

m <- km(~ 1,                         # formula por defecto
        design = df.train, 
        response = y.train,
        optim.method = "gen",        # algo genético
        coef.cov = 1, 
        nugget.estim=TRUE,           # para evitar ruido
        control = list(trace=T,      # para tener todo
                       maxit = 1e4)) # menos de 10000 iteraciones
coef(m)                              # argumentos efectivos

y.pred <- predict(m, newdata = df.test, type = "UK")
     
qplot(y.test,
      y.pred$mean,                
      geom = c("point", "smooth"),
      alpha = I(1/2)
      )
#---------------------------------------------------------------#

