Exemple #1
0
    def seq_to_rp(self, X):

        X_rp = np.empty((len(X), *self.input_shape))

        for i, x in enumerate(X):

            img = RecurrencePlot(**self.rp_params).fit_transform([x])[0]
            img = cv2.resize(img,
                             dsize=self.input_shape[:2],
                             interpolation=cv2.INTER_CUBIC).astype(
                                 self.data_type)

            if np.sum(img) > 0:
                # TODO: improve fit/predict statistics
                # Normalizar
                if self.normalize:
                    img = (img - img.min()) / (img.max() - img.min()
                                               )  # MinMax (0,1)
                #img = (img - img.mean()) / np.max([img.std(), 1e-4])

            #     # centralizar
            #     if centralizar:
            #         img -= img.mean()

            # Padronizar
                elif self.standardize:
                    img = (img - img.mean()) / img.std(
                    )  #tf.image.per_image_standardization(img).numpy()

                elif self.rescale:
                    img = (img - img.min()) / (img.max() - img.min())

            # N canais
            img = np.stack([img for i in range(self.input_shape[-1])],
                           axis=-1).astype(self.data_type)

            X_rp[i, ] = img

        return X_rp
Exemple #2
0
def serie_para_imagem(serie,
                      params_rp=PARAMETROS_RP,
                      tam_imagem=TAMANHO_IMAGEM_RP,
                      normalizar=False,
                      padronizar=False,
                      tipo_dados=TIPO_DADOS):
    """
    Funcao responsavel por gerar e tratar a imagem RP (baseado estudo #17).
    """
    # Gerando imagem RP/redimensiona_prndo
    imagem = RecurrencePlot(**params_rp).fit_transform([serie])[0]
    imagem = cv2.resize(imagem,
                        dsize=tam_imagem[:2],
                        interpolation=cv2.INTER_CUBIC).astype(tipo_dados)

    if np.sum(imagem) > 0:
        # Normalizar
        if normalizar:
            imagem = (imagem - imagem.min()) / (imagem.max() - imagem.min()
                                                )  # MinMax (0,1)
        #imagem = (imagem - imagem.mean()) / np.max([imagem.std(), 1e-4])

    #     # centralizar
    #     if centralizar:
    #         imagem -= imagem.mean()

    # Padronizar
        elif padronizar:
            imagem = (imagem - imagem.mean()) / imagem.std(
            )  #tf.image.per_image_standardization(imagem).numpy()

    # N canais
    imagem = np.stack([imagem for i in range(tam_imagem[-1])],
                      axis=-1).astype(tipo_dados)

    return imagem