| gvSIG desktop 1

 * Copyright (C) 2004-5.

 *

 *

 * Esta clase es de la parte cliente y es la encargada de la gesti?n

 * estos para que la ejecuci?n sea correcta. Un cliente que desee aplicar un

 *

public class RasterFilterStackManager implements IStackManager {

    protected RasterFilterStack filterStack = null;

    private boolean debug = false;

    protected Hashtable typeFilters = new Hashtable();

    public int[] order = null;

    private ArrayList managers = new ArrayList();

    protected ArrayList filterList = null;

    /**

     * Constructor

     * @param filterStack

     */

    public RasterFilterStackManager(RasterFilterStack filterStack) {

        this.filterStack = filterStack;

        typeFilters.put("transparency", new Integer(0));

        typeFilters.put("enhanced", new Integer(1));

        typeFilters.put("computeminmax", new Integer(2));

        typeFilters.put("tail", new Integer(3));

        typeFilters.put("removebands", new Integer(4));

        init();

        this.filterStack.setOrder(order);

    }

    /**

     * Registra un manager del sistema

     * @param manager

     */

    protected void register(IStackManager manager) {

        managers.add(manager);

    }

    /**

     * Inicializaci?n. Asigna el orden de los filtros

     *

     */

    protected void init() {

        order = new int[typeFilters.size()];

        order[0] = ((Integer) typeFilters.get("computeminmax")).intValue();

        order[1] = ((Integer) typeFilters.get("tail")).intValue();

        order[2] = ((Integer) typeFilters.get("enhanced")).intValue();

        order[3] = ((Integer) typeFilters.get("transparency")).intValue();

        order[4] = ((Integer) typeFilters.get("removebands")).intValue();

    }

    /**

     * A?ade un nuevo tipo de filtro

     * @param key        Nombre del filtro

     * @param type        Constante entera asignada a ese tipo

     */

    protected void addTypeFilter(String key, int type, int position) {

        typeFilters.put(key, new Integer(type));

        int[] newOrder = new int[order.length + 1];

        for (int i = 0; i < position; i++)

            newOrder[i] = order[i];

        newOrder[position] = type;

        for (int i = position + 1; i < newOrder.length; i++)

            newOrder[i] = order[i - 1];

        order = newOrder;

        this.filterStack.setOrder(order);

    }

    /**

     * Obtiene la constante correspondiente a un tipo de filtro

     * @param key        Clave para obtener la constante que corresponde al nombre del filtro

     * @return        Tipo de filtro

     */

    public int getTypeFilter(String key) {

        return ((Integer) typeFilters.get(key)).intValue();

    }

    /**

     * A?ade un filtro de transparencia

     * @param red        Intervalos de la banda del rojo a poner transparentes

     * @param green        Intervalos de la banda del verde a poner transparentes

     * @param blue        Intervalos de la banda del azul a poner transparentes

     * @param alpha        Transparencia

     * @param transparencyRed        Color en la banda del rojo de la transparencia

     * @param transparencyGreen        Color en la banda del verde de la transparencia

     * @param transparencyBlue        Color en la banda del azul de la transparencia

     */

    public void addTransparencyFilter(int[][] red, int[][] green, int[][] blue,

                                      int alpha, int transparencyRed,

                                      int transparencyGreen,

                                      int transparencyBlue) {

        RasterFilter filtro = null;

        switch (filterStack.getDataTypeInFilter(((Integer) typeFilters.get("transparency")).intValue())) {

        case RasterBuf.TYPE_IMAGE:

            filtro = new TransparencyImageFilter();

            break;

        case RasterBuf.TYPE_SHORT:

        case RasterBuf.TYPE_USHORT:

        case RasterBuf.TYPE_INT:

            filtro = new TransparencyShortFilter();

            break;

        }

        if (red != null) {

            filtro.addParam("red", red);

        }

        if (green != null) {

            filtro.addParam("green", green);

        }

        if (blue != null) {

            filtro.addParam("blue", blue);

        }

        filtro.addParam("alpha", new Integer(alpha));

        filtro.addParam("transparencyRed", new Integer(transparencyRed));

        filtro.addParam("transparencyGreen", new Integer(transparencyGreen));

        filtro.addParam("transparencyBlue", new Integer(transparencyBlue));

        //Elimina los filtros que son equivalentes a este

        /*for(int i=0;i<filterStack.lenght();i++){

                if( filterStack.get(i) instanceof TransparencyImageFilter ||

                        filterStack.get(i) instanceof TransparencyShortFilter){

                        //Si este filtro es equivalente a uno de la pila se elimina este

                        if(((TransparencyFilter)filtro).isEquivalent((TransparencyFilter)filterStack.get(i)))

                                filterStack.removeFilter(filterStack.get(i));

                }

        }

        //A?ade el filtro si no hay uno equivalente

        boolean equivalentFilter = false;

        for(int i=0;i<filterStack.lenght();i++){

                if( filterStack.get(i) instanceof TransparencyImageFilter ||

                        filterStack.get(i) instanceof TransparencyShortFilter){

                        //Si no existe en la pila un filtro equivalente se a?ade

                        if(((TransparencyFilter)filterStack.get(i)).isEquivalent((TransparencyFilter)filtro)){

                                equivalentFilter = true;

                                break;

                        }

                }

        }

        if(!equivalentFilter)*/

        filterStack.removeFilter(((Integer) typeFilters.get("transparency")).intValue());

        filterStack.addFilter(((Integer) typeFilters.get("transparency")).intValue(),

                              filtro);

        this.controlTypes();

    }

    /**

     * Obtiene el rango de rojo del filtro de transparencia de la pila

     * @return rango de rojo

     */

    public int[][] getTransparecyR() {

        for (int i = 0; i < filterStack.lenght(); i++) {

            if (filterStack.get(i) instanceof TransparencyImageFilter ||

                    filterStack.get(i) instanceof TransparencyShortFilter) {

                return ((TransparencyFilter) filterStack.get(i)).rangesR;

            }

        }

        return null;

    }

    /**

     * Obtiene el rango de verde del filtro de transparencia de la pila

     * @return rango de verde

     */

    public int[][] getTransparecyG() {

        for (int i = 0; i < filterStack.lenght(); i++) {

            if (filterStack.get(i) instanceof TransparencyImageFilter ||

                    filterStack.get(i) instanceof TransparencyShortFilter) {

                return ((TransparencyFilter) filterStack.get(i)).rangesG;

            }

        }

        return null;

    }

    /**

     * Obtiene el rango de azul del filtro de transparencia de la pila

     * @return rango de azul

     */

    public int[][] getTransparecyB() {

        for (int i = 0; i < filterStack.lenght(); i++) {

            if (filterStack.get(i) instanceof TransparencyImageFilter ||

                    filterStack.get(i) instanceof TransparencyShortFilter) {

                return ((TransparencyFilter) filterStack.get(i)).rangesB;

            }

        }

        return null;

    }

    /**

     * A?ade un filtro de eliminado de bandas. Las pone a 0

     * @param bands

     */

    public void addRemoveBands(String bands) {

        RasterFilter filtro = null;

        switch (filterStack.getDataTypeInFilter(((Integer) typeFilters.get("removebands")).intValue())) {

        case RasterBuf.TYPE_IMAGE:

            filtro = new RemoveBandsImageFilter();

            break;

        case RasterBuf.TYPE_SHORT:

        case RasterBuf.TYPE_USHORT:

        case RasterBuf.TYPE_INT:

            filtro = new RemoveBandsShortFilter();

            break;

        }

        filtro.addParam("stats", filterStack.getStats());

        filtro.addParam("bands", bands);

        filterStack.removeFilter(((Integer) typeFilters.get("removebands")).intValue());

        filterStack.addFilter(((Integer) typeFilters.get("removebands")).intValue(),

                              filtro);

        this.controlTypes();

    }

    /**

     * A?ade un filtro de recorte de colas.

     * @param tail        porcentaje de recorte

     * @param samples        porcentaje de muestras tomadas del total de la imagen

     */

    public void addTailFilter(double tail, double samples,

                              boolean removeMaxValue) {

        if (filterStack.isActive(((Integer) typeFilters.get("tail")).intValue())) {

            filterStack.removeFilter(((Integer) typeFilters.get("tail")).intValue());

        }

        RasterFilter filtro = null;

        switch (filterStack.getDataTypeInFilter(((Integer) typeFilters.get("tail")).intValue())) {

        case RasterBuf.TYPE_IMAGE:

            filtro = new PercentTailTrimImageFilter();

            break;

        case RasterBuf.TYPE_SHORT:

        case RasterBuf.TYPE_USHORT:

        case RasterBuf.TYPE_INT:

            filtro = new PercentTailTrimShortFilter();

            break;

        }

        filtro.addParam("stats", filterStack.getStats());

        filtro.addParam("tail", new Double(tail));

        filtro.addParam("samples", new Double(samples));

        filtro.addParam("remove", new Boolean(removeMaxValue));

        filterStack.addFilter(((Integer) typeFilters.get("tail")).intValue(),

                              filtro);

        this.controlTypes();

    }

    /**

     * A?ade un filtro de realce. Esta versi?n tiene el par?metro para a?adirle el nombre

     * del fichero. Esto se usa para que si a un fichero se le ha calculado ya el recorte de colas

     * no se vuelva a calcular, evitando as? que si hacemos un draw a una imagen por bloques cada

     * bloque tenga un calculo distinto para el recorte.

     */

    public void addEnhancedFilter(boolean remove, String fileName) {

        if (filterStack.isActive(((Integer) typeFilters.get("enhanced")).intValue())) {

            filterStack.removeFilter(((Integer) typeFilters.get("enhanced")).intValue());

        }

        RasterFilter filtro = null;

        switch (filterStack.getDataTypeInFilter(((Integer) typeFilters.get("enhanced")).intValue())) {

        case RasterBuf.TYPE_IMAGE:

            filtro = new LinearEnhancementImageFilter();

            break;

        case RasterBuf.TYPE_SHORT:

        case RasterBuf.TYPE_USHORT:

        case RasterBuf.TYPE_INT:

            filtro = new LinearEnhancementShortFilter();

            break;

        }

        filtro.addParam("stats", filterStack.getStats());

        if (remove) {

            filtro.addParam("remove", new Boolean(true));

        } else {

            filtro.addParam("remove", new Boolean(false));

        }

        if (fileName != null) {

            filtro.addParam("filename", fileName);

        } else {

            filtro.addParam("filename", new String(""));

        }

        filterStack.addFilter(((Integer) typeFilters.get("enhanced")).intValue(),

                              filtro);

        this.controlTypes();

    }

    /**

     * A?ade un filtro de realce

     */

    public void addEnhancedFilter(boolean remove) {

        addEnhancedFilter(remove, "");

    }

    /**

     * A?ade un filtro ComputeMinMax

     */

    public void addComputeMinMaxFilter() {

        if (!filterStack.isActive(((Integer) typeFilters.get("computeminmax")).intValue())) { //Solo lo a?adimos si no est?

            RasterFilter filtro = null;

            switch (filterStack.getDataTypeInFilter(((Integer) typeFilters.get("computeminmax")).intValue())) {

            case RasterBuf.TYPE_IMAGE:

                filtro = new ComputeMinMaxImageFilter();

                break;

            case RasterBuf.TYPE_SHORT:

            case RasterBuf.TYPE_USHORT:

            case RasterBuf.TYPE_INT:

                filtro = new ComputeMinMaxShortFilter();

                break;

            }

            filtro.addParam("stats", filterStack.getStats());

            filterStack.addFilter(((Integer) typeFilters.get("computeminmax")).intValue(),

                                  filtro);

        }

        this.controlTypes();

    }

    /**

     * Obtiene el tipo de filtro a partir del objeto RasterFilter

     * @param rasterFilter        Objeto RasterFilter del cual se quiere saber que tipo de filtro contiene

     * @return        Tipo de filtro seg?n las constantes contenidas en RasterFilterStackManager

     */

    protected int getType(RasterFilter rasterFilter) {

        if (rasterFilter instanceof TransparencyFilter) {

            return 0;

        }

        if (rasterFilter instanceof LinearEnhancementFilter) {

            return 1;

        }

        if (rasterFilter instanceof ComputeMinMaxFilter) {

            return 2;

        }

        if (rasterFilter instanceof PercentTailTrimFilter) {

            return 3;

        }

        return -1;

    }

    /**

     * Controla que los tipos de los filtros de la pila sean correctos, es decir, que

     * el tipo de salida de un filtro de salida coincida con el tipo de la entrada del

     * siguiente. En caso de no ser as? crea el filtro de tipo adecuado y lo sustituye

     * en el no coincidente. Esto es necesario ya que en la eliminaci?n de filtros puede

     * quedarse en inconsistencia de tipos.

     */

    protected void controlTypes() {

        if (debug) {

            filterStack.show();

        }

        for (int i = filterStack.lenght(); i >= 0; i--) {

            if ((i - 1) >= 0) {

                //Para el primer filtro comprobamos con el tipo de dato de entrada a la pila

                if (i == filterStack.lenght()) {

                    if (filterStack.getInitDataType() != filterStack.get(i - 1)

                                                                        .getInRasterDataType()) {

                        String oldClass = filterStack.get(i - 1).getClass()

                                                     .toString().substring(filterStack.get(i -

                                                                                           1)

                                                                                      .getClass()

                                                                                      .toString()

                                                                                      .lastIndexOf(".") +

                                                                           1,

                                                                           filterStack.get(i -

                                                                                           1)

                                                                                      .getClass()

                                                                                      .toString()

                                                                                      .length());

                        Pattern p = Pattern.compile(RasterBuf.typesToString(filterStack.get(i -

                                                                                            1)

                                                                                       .getInRasterDataType()));

                        Matcher m = p.matcher(oldClass);

                        String newClass = m.replaceAll(RasterBuf.typesToString(filterStack.getInitDataType()));

                        //System.out.println("==>"+oldClass+" "+newClass);

                        try {

                            Class filterClass = Class.forName("org.cresques.io.raster." +

                                                              newClass);

                            Constructor con = filterClass.getConstructor(null);

                            RasterFilter newFilter = (RasterFilter) con.newInstance(null);

                            newFilter.params = filterStack.get(i - 1).params;

                            filterStack.replace(newFilter, i - 1,

                                                this.getType(newFilter));

                        } catch (Exception e) {

                            e.printStackTrace();

                        }

                    }

                    //Desde el filtro 2 en adelante se compara la salida de uno con la entrada del siguiente

                } else if (filterStack.get(i).getOutRasterDataType() != filterStack.get(i -

                                                                                            1)

                                                                                       .getInRasterDataType()) {

                    String oldClass = filterStack.get(i - 1).getClass()

                                                 .toString().substring(filterStack.get(i -

                                                                                       1)

                                                                                  .getClass()

                                                                                  .toString()

                                                                                  .lastIndexOf(".") +

                                                                       1,

                                                                       filterStack.get(i -

                                                                                       1)

                                                                                  .getClass()

                                                                                  .toString()

                                                                                  .length());

                    Pattern p = Pattern.compile(RasterBuf.typesToString(filterStack.get(i -

                                                                                        1)

                                                                                   .getInRasterDataType()));

                    Matcher m = p.matcher(oldClass);

                    String newClass = m.replaceAll(RasterBuf.typesToString(filterStack.get(i)

                                                                                      .getOutRasterDataType()));

                    //System.out.println("==>"+oldClass+" "+newClass);

                    try {

                        Class filterClass = Class.forName("org.cresques.io.raster." +

                                                          newClass);

                        Constructor con = filterClass.getConstructor(null);

                        RasterFilter newFilter = (RasterFilter) con.newInstance(null);

                        newFilter.params = filterStack.get(i - 1).params;

                        filterStack.replace(newFilter, i - 1,

                                            this.getType(newFilter));

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                }

            }

        }

        if (debug) {

            filterStack.show();

        }

    }

    /**

     * M?todo que devuelve true si el tipo de filtro pasado por par?metro est? en la

     * pila y false si no lo est?.

     * @param filter        Tipo de filtro a comprobar

     * @return true si est? en la pila y false si no lo est?

     */

    public boolean isActive(int type) {

        return filterStack.isActive(type);

    }

    /**

     * Elimina los filtros de la pila de un determinado tipo

     * @param type        Tipo de filtro a eliminar

     */

    public void removeFilter(int type) {

        filterStack.removeFilter(type);

        this.controlTypes();

    }

    /**

     * Resetea el flag de temporalidad de los filtros de la pila.

     * Esto equivale a fijar los filtros que ya existen en la pila. A partir de

     * ese momento los filtros que se introduzcan podr?n ser eliminados de golpe

     * llamando a la funci?n deleteTempFilters

     */

    public void resetTempFilters() {

        filterStack.resetTempFilters();

    }

    /**

     * Elimina los filtros temporales, es decir, todos los filtros introducidos desde

     * el ?ltimo resetTempFilters que se ha realizado.

     */

    public void deleteTempFilters() {

        filterStack.deleteTempFilters();

    }

    /**

     * Obtiene el objeto de estadisticas asignado a la pila.

     * @return

     */

    public RasterStats getStackStats() {

        return filterStack.getStats();

    }

    /* (non-Javadoc)

     * @see org.cresques.io.raster.StackManager#getStringsFromStack()

     */

    public ArrayList getStringsFromStack() {

        filterList = new ArrayList();

        for (int i = 0; i < filterStack.lenght(); i++) {

            RasterFilter rf = filterStack.get(i);

            if (rf instanceof TransparencyFilter) {

                filterList.add("filter.transparency.active=true");

                filterList.add("filter.transparency.rangeR=" +

                               rangeToString(((TransparencyFilter) rf).getRangeR()));

                filterList.add("filter.transparency.rangeG=" +

                               rangeToString(((TransparencyFilter) rf).getRangeG()));

                filterList.add("filter.transparency.rangeB=" +

                               rangeToString(((TransparencyFilter) rf).getRangeB()));

            } else if (rf instanceof LinearEnhancementFilter) {

                filterList.add("filter.enhanced.active=true");

                filterList.add("filter.enhanced.remove=" +

                               ((LinearEnhancementFilter) rf).getRemoveExtrema()

                                .toString());

            } else if (rf instanceof ComputeMinMaxFilter) {

                filterList.add("filter.computeminmax.active=true");

            } else if (rf instanceof PercentTailTrimFilter) {

                filterList.add("filter.tail.active=true");

                filterList.add("filter.tail.value=" +

                               this.getStackStats().tailPercent);

                filterList.add("filter.tail.remove=" +

                               ((PercentTailTrimFilter) rf).removeMaxValue());

            } else if (rf instanceof RemoveBandsFilter) {

                filterList.add("filter.removebands.active=true");

                filterList.add("filter.removebands.bands=" +

                               ((RemoveBandsFilter) rf).bands);

            } else { //Se recorren todos los managers registrados comprobando si corresponde a la clase del filtro 

                for (int j = 0; j < managers.size(); j++)

                    ((IStackManager) managers.get(j)).getStringsFromStack();

            }

        }

        return filterList;

    }

    /**

     * Crea una pila de filtros a partir de un Array de Strings. Cada elemento del array debe

     * tener la forma elemento=valor.

     * @param filters

     */

    public void createStackFromStrings(ArrayList f) {

        this.createStackFromStrings(f, new Integer(0));

    }

    /* (non-Javadoc)

     * @see org.cresques.io.raster.StackManager#createStackFromStrings(java.util.ArrayList)

     */

    public void createStackFromStrings(ArrayList f, Integer pos) {

        ArrayList filters = (ArrayList) f.clone();

        filterStack.clear();

        int filteri = pos.intValue();

        //Busca un filtro activo y despu?s todas las propiedades que necesita ese filtro para

        //ser creado. Una vez las tiene a?ade en la pila el tipo de filtro.

        while ((filters.size() > 0) && (filteri < filters.size())) {

            String fil = (String) filters.get(filteri);

            if (fil.startsWith("filter.transparency.active") &&

                    getValue(fil).equals("true")) {

                filters.remove(filteri);

                int[][] r = null;

                int[][] g = null;

                int[][] b = null;

                for (int propFilter = 0; propFilter < filters.size();

                         propFilter++) {

                    String elem = (String) filters.get(propFilter);

                    if (elem.startsWith("filter.transparency.rangeR")) {

                        r = stringToRange(getValue(elem));

                        filters.remove(propFilter);

                        propFilter--;

                    }

                    if (elem.startsWith("filter.transparency.rangeG")) {

                        g = stringToRange(getValue(elem));

                        filters.remove(propFilter);

                        propFilter--;

                    }

                    if (elem.startsWith("filter.transparency.rangeB")) {

                        b = stringToRange(getValue(elem));

                        filters.remove(propFilter);

                        propFilter--;

                    }

                }

                this.addTransparencyFilter(r, g, b, 0x10, 0xff, 0xff, 0xff);

                filteri = -1;

            }

            if (fil.startsWith("filter.enhanced.active") &&

                    getValue(fil).equals("true")) {

                filters.remove(filteri);

                boolean remove = false;

                for (int propFilter = 0; propFilter < filters.size();

                         propFilter++) {

                    String elem = (String) filters.get(propFilter);

                    if (elem.startsWith("filter.enhanced.remove")) {

                        this.addEnhancedFilter(Boolean.valueOf(getValue(elem))

                                                      .booleanValue());

                        filters.remove(propFilter);

                        propFilter--;

                    }

                }

                this.addComputeMinMaxFilter();

                filteri = -1;

            }

            if (fil.startsWith("filter.tail.active") &&

                    getValue(fil).equals("true")) {

                filters.remove(filteri);

                this.removeFilter(this.getTypeFilter("computeminmax"));

                double recorte = 0D;

                boolean remove = false;

                for (int propFilter = 0; propFilter < filters.size();

                         propFilter++) {

                    String elem = (String) filters.get(propFilter);

                    if (elem.startsWith("filter.tail.value")) {

                        recorte = Double.parseDouble(getValue(elem));

                        filters.remove(propFilter);

                        propFilter--;

                    }

                    if (elem.startsWith("filter.tail.remove")) {

                        remove = Boolean.valueOf(getValue(elem)).booleanValue();

                        filters.remove(propFilter);

                        propFilter--;

                    }

                }

                this.addTailFilter(recorte, 0D, remove);

                filteri = -1;

            }

            if (fil.startsWith("filter.removebands.active") &&

                    getValue(fil).equals("true")) {

                filters.remove(filteri);

                boolean remove = false;

                for (int propFilter = 0; propFilter < filters.size();

                         propFilter++) {

                    String elem = (String) filters.get(propFilter);

                    if (elem.startsWith("filter.removebands.bands")) {

                        this.addRemoveBands(getValue(elem));

                        filters.remove(propFilter);

                        propFilter--;

                    }

                }

                filteri = -1;

            }

            for (int j = 0; j < managers.size(); j++)

                ((IStackManager) managers.get(j)).createStackFromStrings(filters,

                                                                         new Integer(filteri));

            filteri++;

        }

    }

    /**

     * Obtiene el elemento de una cadena de la forma elemento=valor

     * @param cadena

     * @return

     */

    public String getElem(String cadena) {

        if (cadena != null) {

            return cadena.substring(0, cadena.indexOf("="));

        } else {

            return null;

        }

    }

    /**

     * Obtiene el valor de una cadena de la forma elemento=valor

     * @param cadena

     * @return

     */

    public String getValue(String cadena) {

        if (cadena != null) {

            return cadena.substring(cadena.indexOf("=") + 1, cadena.length());

        } else {

            return null;

        }

    }

    /**

     * Convierte un rango contenido en una array doble en una cadena

     * de strings para poder salvar a xml

     * @param rang

     * @return

     */

    private String rangeToString(int[][] rang) {

        StringBuffer rangoStr = new StringBuffer();

        if (rang != null) {

            for (int i = 0; i < rang.length; i++) {

                rangoStr.append(String.valueOf(rang[i][0]) + ":");

                rangoStr.append(String.valueOf(rang[i][1]) + ":");

            }

            String r = rangoStr.toString();

            if (r.endsWith(":")) {

                r = r.substring(0, r.length() - 1);

            }

            return r;

        } else {

            return null;

        }

    }

    /**

     * Convierte una cadena en una lista de rangos numericos para poder

     * asignar transparencias a la imagen

     * @param rang

     * @return

     */

    private int[][] stringToRange(String rang) {

        if ((rang != null) && !rang.equals("null")) {

            ArrayList lista = new ArrayList();

            StringTokenizer tokenizer = new StringTokenizer(rang, ":");

            while (tokenizer.hasMoreTokens())

                lista.add(tokenizer.nextToken());

            int[][] intervalos = new int[(int) (lista.size() / 2)][2];

            for (int i = 0; i < lista.size(); i = i + 2) {

                intervalos[i / 2][0] = Integer.valueOf((String) lista.get(i))

                                              .intValue();

                intervalos[i / 2][1] = Integer.valueOf((String) lista.get(i +

                                                                          1))

                                              .intValue();

            }

            return intervalos;

        } else {

            return null;

        }

    }

}