Example usage for org.jfree.data.statistics HistogramDataset HistogramDataset

List of usage examples for org.jfree.data.statistics HistogramDataset HistogramDataset

Introduction

In this page you can find the example usage for org.jfree.data.statistics HistogramDataset HistogramDataset.

Prototype

public HistogramDataset() 

Source Link

Document

Creates a new (empty) dataset with a default type of HistogramType .FREQUENCY.

Usage

From source file:org.jfree.chart.demo.ThumbnailDemo1.java

private static IntervalXYDataset createDataset5() {
    HistogramDataset histogramdataset = new HistogramDataset();
    double ad[] = new double[1000];
    Random random = new Random(0xbc614eL);
    for (int i = 0; i < 1000; i++)
        ad[i] = random.nextGaussian() + 5D;

    histogramdataset.addSeries("H1", ad, 100, 2D, 8D);
    ad = new double[1000];
    for (int j = 0; j < 1000; j++)
        ad[j] = random.nextGaussian() + 7D;

    histogramdataset.addSeries("H2", ad, 100, 4D, 10D);
    return histogramdataset;
}

From source file:com.compomics.cell_coord.gui.controller.computation.ComputationDataController.java

/**
 *
 * @param track//from w  w  w  .j  av a  2  s  . c  om
 */
private void plotAngles(Track track) {
    double[] values = ArrayUtils.toPrimitive(ComputationUtils.excludeNullValues(track.getAngles()));
    HistogramDataset histogramDataset = new HistogramDataset();
    histogramDataset.addSeries("", values, 5);
    String title = "angles for track: " + track.getTrackid();
    JFreeChart jFreeChart = ChartFactory.createHistogram(title, "angle", "count", histogramDataset,
            PlotOrientation.VERTICAL, true, true, true);
    ChartPanel chartPanel = new ChartPanel(jFreeChart);
    computationDataPanel.getAnglePlotPanel().removeAll();
    computationDataPanel.getAnglePlotPanel().add(chartPanel, gridBagConstraints);
    computationDataPanel.getAnglePlotPanel().revalidate();
    computationDataPanel.getAnglePlotPanel().repaint();
}

From source file:v800_trainer.JHistogram.java

public JPanel StartHistoHm(JCicloTronic JTronicHandle) {

    boolean Summenhisto;
    int von = 0;//from  w w w  .j a v a  2  s  .  c o m
    int bis = 0;
    int num = 0;
    int selected;
    int single;
    int Gruppen = 0;
    int i = 100;
    int j = 10;
    int m = 0;
    int n = 0;
    int Linecount = 0;
    int Anzahl = 1;

    JFreeChart chart;

    double DummyData[] = new double[1];

    selected = JTronicHandle.Auswahl_Histogramm.getSelectedIndex();
    Summenhisto = JTronicHandle.Summenhistogramm_Check.isSelected();

    chart = ChartFactory.createHistogram("", "Steigung [m/min]", "Hufigkeit", new HistogramDataset(),
            PlotOrientation.HORIZONTAL, true, true, true);

    chart.setBackgroundPaint(Color.white);

    JTronicHandle.applyChartTheme(chart);

    XYPlot plot = chart.getXYPlot();
    plot.setOrientation(PlotOrientation.VERTICAL);
    plot.setBackgroundPaint(Color.lightGray);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);

    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
    plot.getRangeAxis().setFixedDimension(15.0);

    ArrayList Bufferarray = new ArrayList();
    double Buffer;

    if (selected == 0) {
        single = 1;
    } else {
        single = 0;
        Summenhisto = false;
    }
    ;

    try {
        von = Integer.parseInt(JTronicHandle.Properties.getProperty("HistovonHm", "100"));
        bis = Integer.parseInt(JTronicHandle.Properties.getProperty("HistobisHm", "200"));
        Gruppen = Integer.parseInt(JTronicHandle.Properties.getProperty("HistostepHm", "10"));
        Anzahl = (JTronicHandle.Auswahl_Histogramm.getItemCount() - 2) * single + 1;
        for (j = 0; j < Anzahl; j++) {
            if (single == 1) {
                selected = j + 1;
            }
            if (!Summenhisto) {
                num = JTronicHandle.Statistikhandle.TourData[selected].Datenpunkte;
            } else {
                num += JTronicHandle.Statistikhandle.TourData[selected].Datenpunkte;
            }

            n = 0;
            if (!Summenhisto) {
                create_Start_Stop(JTronicHandle, selected); //die limits einer gezoomten Graphik ermitteln

                for (i = start; i < stop; i++) {
                    Buffer = (double) JTronicHandle.Statistikhandle.TourData[selected].Steigm_gesZeit[i];
                    if (Buffer >= von && Buffer <= bis) {
                        Bufferarray.add(Buffer);
                    }
                }
            } else {
                for (i = 0; i < j + 1; i++) {
                    create_Start_Stop(JTronicHandle, i + 1);
                    for (m = start; m < stop; m++) {
                        Buffer = (double) JTronicHandle.Statistikhandle.TourData[i + 1].Steigm_gesZeit[m];
                        if (Buffer >= von && Buffer <= bis) {
                            Bufferarray.add(Buffer);
                        }

                    }

                }
            }

            DummyData = new double[Bufferarray.size()];

            for (i = 0; i < Bufferarray.size(); i++) {
                DummyData[i] = new Double(Bufferarray.get(i).toString());
            }

            if (!Summenhisto) {
                HistogramDataset histoHM = new HistogramDataset();
                histoHM.addSeries(
                        "" + JTronicHandle.Statistikhandle.TourData[selected].Tag + "."
                                + JTronicHandle.Statistikhandle.TourData[selected].Monat + "."
                                + JTronicHandle.Statistikhandle.TourData[selected].Jahr,
                        DummyData, Gruppen, (double) von, (double) bis);
                histoHM.setType(HistogramType.RELATIVE_FREQUENCY);
                plot.setDataset(Linecount, histoHM);
                plot.mapDatasetToRangeAxis(Linecount, 0);
                XYBarRenderer renderer = new XYBarRenderer();
                renderer.setDrawBarOutline(true);

                renderer.setSeriesPaint(0, getColour(Linecount, (int) 255 / Anzahl));

                renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
                plot.setRenderer(Linecount, renderer);

            }
            Linecount++;
        }
    } catch (Exception e) {
        JOptionPane.showMessageDialog(null, "StartHistoSp\nFehler: Hm " + e + " " + i + " " + j, "Achtung!",
                JOptionPane.ERROR_MESSAGE);
    }

    if (Summenhisto) {
        HistogramDataset histoHM = new HistogramDataset();
        histoHM.addSeries("Summenhistogram", DummyData, Gruppen, (double) von, (double) bis);
        histoHM.setType(HistogramType.RELATIVE_FREQUENCY);

        plot.setDataset(0, histoHM);
        plot.mapDatasetToRangeAxis(0, 0);
        XYItemRenderer renderer = new XYBarRenderer();
        renderer.setSeriesPaint(0, Color.blue);
        renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());

        plot.setRenderer(0, renderer);
    }
    chart.setPadding(padding);
    ChartPanel Panel = new ChartPanel(chart);

    return Panel;
}

From source file:org.matsim.contrib.parking.parkingchoice.lib.GeneralLib.java

public static void generateHistogram(String fileName, double[] value, int numberOfBins, String title,
        String xLabel, String yLabel) {
    HistogramDataset dataset = new HistogramDataset();
    dataset.setType(HistogramType.FREQUENCY);
    dataset.addSeries(title, value, numberOfBins);
    String plotTitle = title;/*w w w . java2 s . c  o m*/
    String xaxis = xLabel;
    String yaxis = yLabel;
    PlotOrientation orientation = PlotOrientation.VERTICAL;
    boolean show = false;
    boolean toolTips = false;
    boolean urls = false;
    JFreeChart chart = ChartFactory.createHistogram(plotTitle, xaxis, yaxis, dataset, orientation, show,
            toolTips, urls);
    int width = 500;
    int height = 300;
    try {
        ChartUtilities.saveChartAsPNG(new File(fileName), chart, width, height);
    } catch (IOException e) {

    }
}

From source file:at.tuwien.ifs.feature.evaluation.SimilarityRetrievalGUI.java

private void initButtonStart() {
    btnStart = new JButton("Start");
    btnStart.setEnabled(false);/*from ww w .  j  a  va  2  s. c  om*/
    btnStart.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            Enumeration<AbstractButton> elements = bgInputData.getElements();
            while (elements.hasMoreElements()) {
                InputDataRadioButton rb = (InputDataRadioButton) elements.nextElement();
                if (rb.isSelected()) {
                    AbstractSOMLibSparseInputData inputData = rb.inputData;
                    try {
                        @SuppressWarnings("unchecked")
                        Class<? extends DistanceMetric> selectedClass = ((ClassComboBoxModel<DistanceMetric>) boxMetric
                                .getModel()).getSelectedClass();
                        int inputDatumIndex = inputData
                                .getInputDatumIndex((String) comboQueryVector.getSelectedItem());
                        DistanceMetric metric = AbstractMetric.instantiateNice(selectedClass.getName());
                        ArrayList<InputDistance> distances = inputData.getDistances(inputDatumIndex, metric);
                        Collections.sort(distances);

                        // prepare the data for the table
                        double maxDistance = distances.get(distances.size() - 1).getDistance();

                        int neighbours = modelNumberNeighbours.getNumber().intValue();
                        String actionCommand = bgDistanceDisplay.getSelection().getActionCommand();
                        boolean isAbsolute = !actionCommand.equals("relative");

                        Object[][] data = new Object[neighbours][3];
                        if (isAbsolute) {
                            for (int i = 0; i < data.length; i++) {
                                data[i] = new Object[] { i + 1, distances.get(i).getInput().getLabel(),
                                        NumberUtils.setScale(4, distances.get(i).getDistance()) };
                            }
                        } else {
                            for (int i = 0; i < data.length; i++) {
                                data[i] = new Object[] { i + 1, distances.get(i).getInput().getLabel(),
                                        StringUtils.formatAsPercent(distances.get(i).getDistance(), maxDistance,
                                                3) };
                            }
                        }
                        resultsTable.setModel(new DefaultTableModel(data, resultColumnNames));
                        resizeResultTableColumns();

                        // prepare the data for the chart
                        double[] values = InputDistance.getDistanceValuesOnly(distances);
                        if (!isAbsolute) { // convert values to percent
                            for (int i = 0; i < values.length; i++) {
                                values[i] = values[i] * 100.0 / maxDistance;
                            }
                        }

                        HistogramDataset ds = new HistogramDataset();
                        ds.addSeries("Distance", values, 100, 0, isAbsolute ? maxDistance : 100);
                        JFreeChart chart = ChartFactory.createHistogram(null,
                                isAbsolute ? "absolute distance" : "distance in percent", "# of objects", ds,
                                PlotOrientation.VERTICAL, false, true, true);
                        chartPanel.setChart(chart);

                    } catch (SOMToolboxException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                }
            }
            // enable the saveAs button
            btnSaveResults.setEnabled(true);
        }

    });
}

From source file:v800_trainer.JHistogram.java

public JPanel StartHistoCd(JCicloTronic JTronicHandle) {

    boolean Summenhisto;
    int von = 0;/*  ww w.j  a  v  a  2 s  . c om*/
    int bis = 0;
    int num = 0;
    int selected;
    int single;
    int Gruppen = 0;
    int i = 100;
    int j = 10;
    int m = 0;
    int n = 0;
    int Linecount = 0;
    int Anzahl = 1;

    JFreeChart chart;

    double DummyData[] = new double[1];

    selected = JTronicHandle.Auswahl_Histogramm.getSelectedIndex();
    Summenhisto = JTronicHandle.Summenhistogramm_Check.isSelected();

    chart = ChartFactory.createHistogram("", "Cadence [n/min]", "Hufigkeit", new HistogramDataset(),
            PlotOrientation.HORIZONTAL, true, true, true);

    chart.setBackgroundPaint(Color.white);

    JTronicHandle.applyChartTheme(chart);

    XYPlot plot = chart.getXYPlot();
    plot.setOrientation(PlotOrientation.VERTICAL);
    plot.setBackgroundPaint(Color.lightGray);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);

    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
    plot.getRangeAxis().setFixedDimension(15.0);

    ArrayList Bufferarray = new ArrayList();
    double Buffer;

    if (selected == 0) {
        single = 1;
    } else {
        single = 0;
        Summenhisto = false;
    }

    try {
        von = Integer.parseInt(JTronicHandle.Properties.getProperty("HistovonCd", "100"));
        bis = Integer.parseInt(JTronicHandle.Properties.getProperty("HistobisCd", "200"));
        Gruppen = Integer.parseInt(JTronicHandle.Properties.getProperty("HistostepCd", "10"));
        Anzahl = (JTronicHandle.Auswahl_Histogramm.getItemCount() - 2) * single + 1;
        for (j = 0; j < Anzahl; j++) {
            if (single == 1) {
                selected = j + 1;
            }
            if (!Summenhisto) {
                num = JTronicHandle.Statistikhandle.TourData[selected].Datenpunkte;
            } else {
                num += JTronicHandle.Statistikhandle.TourData[selected].Datenpunkte;
            }

            n = 0;
            if (!Summenhisto) {
                create_Start_Stop(JTronicHandle, selected); //die limits einer gezoomten Graphik ermitteln

                for (i = start; i < stop; i++) {
                    Buffer = (double) JTronicHandle.Statistikhandle.TourData[selected].Cadence_gesZeit[i];
                    if (Buffer >= von && Buffer <= bis) {
                        Bufferarray.add(Buffer);
                    }
                }
            } else {
                for (i = 0; i < j + 1; i++) {
                    create_Start_Stop(JTronicHandle, i + 1);

                    for (m = start; m < stop; m++) {
                        Buffer = (double) JTronicHandle.Statistikhandle.TourData[i + 1].Cadence_gesZeit[m];
                        if (Buffer >= von && Buffer <= bis) {
                            Bufferarray.add(Buffer);
                        }

                    }
                    n += m;
                }
            }

            DummyData = new double[Bufferarray.size()];

            for (i = 0; i < Bufferarray.size(); i++) {
                DummyData[i] = new Double(Bufferarray.get(i).toString());
            }

            if (!Summenhisto) {
                HistogramDataset histoHM = new HistogramDataset();
                histoHM.addSeries(
                        "" + JTronicHandle.Statistikhandle.TourData[selected].Tag + "."
                                + JTronicHandle.Statistikhandle.TourData[selected].Monat + "."
                                + JTronicHandle.Statistikhandle.TourData[selected].Jahr,
                        DummyData, Gruppen, (double) von, (double) bis);
                histoHM.setType(HistogramType.RELATIVE_FREQUENCY);
                plot.setDataset(Linecount, histoHM);
                plot.mapDatasetToRangeAxis(Linecount, 0);
                XYBarRenderer renderer = new XYBarRenderer();
                renderer.setDrawBarOutline(true);

                renderer.setSeriesPaint(0, getColour(Linecount, (int) 255 / Anzahl));

                renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
                plot.setRenderer(Linecount, renderer);

            }
            Linecount++;
        }
    } catch (Exception e) {
        JOptionPane.showMessageDialog(null, "StartHistoCd\nFehler: Cd " + e + " " + i + " " + j, "Achtung!",
                JOptionPane.ERROR_MESSAGE);
    }

    if (Summenhisto) {
        HistogramDataset histoHM = new HistogramDataset();
        histoHM.addSeries("Summenhistogram", DummyData, Gruppen, (double) von, (double) bis);
        histoHM.setType(HistogramType.RELATIVE_FREQUENCY);

        plot.setDataset(0, histoHM);
        plot.mapDatasetToRangeAxis(0, 0);
        XYItemRenderer renderer = new XYBarRenderer();
        renderer.setSeriesPaint(0, Color.blue);
        renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());

        plot.setRenderer(0, renderer);
    }
    ;
    chart.setPadding(padding);
    ChartPanel Panel = new ChartPanel(chart);

    return Panel;

}

From source file:net.sf.mzmine.chartbasics.HistogramChartFactory.java

public static JFreeChart createHistogramOld(double[] data, int bin, String yAxisLabel, double min, double max) {
    if (data != null && data.length > 0) {
        HistogramDataset dataset = new HistogramDataset();
        dataset.addSeries("histo", data, bin, min, max);

        JFreeChart chart = ChartFactory.createHistogram("", yAxisLabel, "n", dataset, PlotOrientation.VERTICAL,
                true, false, false);/* w w  w .j a  v a  2  s .co  m*/

        chart.setBackgroundPaint(new Color(230, 230, 230));
        chart.getLegend().setVisible(false);
        XYPlot xyplot = chart.getXYPlot();
        xyplot.setForegroundAlpha(0.7F);
        xyplot.setBackgroundPaint(Color.WHITE);
        xyplot.setDomainGridlinePaint(new Color(150, 150, 150));
        xyplot.setRangeGridlinePaint(new Color(150, 150, 150));
        xyplot.getDomainAxis().setVisible(true);
        xyplot.getRangeAxis().setVisible(yAxisLabel != null);
        XYBarRenderer xybarrenderer = (XYBarRenderer) xyplot.getRenderer();
        xybarrenderer.setShadowVisible(false);
        xybarrenderer.setBarPainter(new StandardXYBarPainter());
        // xybarrenderer.setDrawBarOutline(false);
        return chart;
    } else
        return null;
}

From source file:org.neuroph.netbeans.main.DataSetStatTopComponent.java

/**
 * Returns data set for give column index.
 *
 * @return Dataset for give column index.
 */// ww  w .ja v  a  2s  . c o  m
private HistogramDataset createHistogramDataSet() {
    int columnIndex = Integer.parseInt(columnsComboBox.getSelectedItem().toString());
    int binsCount = Integer.parseInt(histogramBinsComboBox.getSelectedItem().toString());
    HistogramDataset chartDataset = new HistogramDataset();
    DataSet dataSet = statistics.getDataSet();
    int rowCount = dataSet.getRows().size();
    double[] values = new double[rowCount];

    for (int i = 0; i < rowCount; i++) {
        double[] row = dataSet.getRowAt(i).toArray();
        values[i] = row[columnIndex];
    }

    chartDataset.addSeries(dataSet.getColumnName(columnIndex), values, binsCount);
    return chartDataset;
}

From source file:org.talend.dataprofiler.chart.TOPChartService.java

@Override
public Object createHistogramDataset(double[] valueArray, double maxValue, int bins) {
    HistogramDataset defaultcategorydataset = new HistogramDataset();
    if (valueArray == null) {
        return defaultcategorydataset;
    }/*from   ww  w. j  av a2  s.com*/
    defaultcategorydataset.addSeries("Key distribution", valueArray, bins, 0, maxValue); //$NON-NLS-1$
    return defaultcategorydataset;
}

From source file:tarea1.controlador.java

public void seleccionOpcion(int z) throws IOException, Exception {
    switch (z) {/*from  w  w  w .  ja va 2s .com*/
    case 1: {
        //ELEGIR UN ARCHIVO//
        //EN CASO DE QUERER CAMBIAR EL TIPO DE ARCHIVO.
        FileNameExtensionFilter filter = new FileNameExtensionFilter("Image Files", "bmp");
        JFileChooser abrir = new JFileChooser();
        abrir.setFileSelectionMode(JFileChooser.FILES_ONLY);
        abrir.setFileFilter(filter);
        abrir.setCurrentDirectory(new File(System.getProperty("user.home")));
        int result = abrir.showOpenDialog(inicio);
        if (result == JFileChooser.APPROVE_OPTION) {
            // se seleciona el archivo de imagen original
            File selectedFile = abrir.getSelectedFile();
            ruta = selectedFile.getAbsolutePath();
            System.out.println("El archivo es: " + ruta); //ruta
            img = ImageIO.read(new File(ruta)); //se lee el archivo
            rotate = false;
            zoomv = false;
            escalav = false;
            brillos = false;
            contrastes = false;
            undoDelete = false;
            undoIndex = 0;
            Change();
            inicio.setTitle("PDI: Tarea 3 -" + ruta);

        }
    }
        break;//end case 1

    case 2: //imagen en negativo
    {

        //se crea un buffer
        BufferedImage imagenNegativa = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        //se convierten los colores a negativo y se va guardando en el buffer
        for (int y = 0; y < alto; y++) {
            for (int x = 0; x < ancho; x++) {
                int p = img.getRGB(x, y);
                //obtenermos el valor r g b a de cada pixel
                // int a = (p>>24)&0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;
                //se resta el rbg
                r = truncate(255 - r);
                g = truncate(255 - g);
                b = truncate(255 - b);
                //se guarda el rgb
                p = (r << 16) | (g << 8) | b;
                imagenNegativa.setRGB(x, y, p);
            }
        }
        //PARA LOS ROTACIONES
        img = imagenNegativa;

        ancho = img.getWidth();
        alto = img.getHeight();
        //se crea un buffer
        imagenNegativa = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        //se convierten los colores a negativo y se va guardando en el buffer
        for (int y = 0; y < alto; y++) {
            for (int x = 0; x < ancho; x++) {
                int p = original.getRGB(x, y);
                //obtenermos el valor r g b a de cada pixel
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;
                //se resta el rbg
                r = 255 - r;
                g = 255 - g;
                b = 255 - b;
                //se guarda el rgb
                p = (a << 24) | (r << 16) | (g << 8) | b;
                imagenNegativa.setRGB(x, y, p);
            }
        }
        img = imagenNegativa;

        Change();
    }
        break;//end case 2

    case 3: //flip imagen vertical
    {

        //buffer para la imagen
        BufferedImage mirrorimgV = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        //recorremos pixel a pixel tooooooooooooodo el buffer
        for (int i = 0; i < alto; i++) {
            for (int izquierda = 0, derecha = ancho - 1; izquierda < alto; izquierda++, derecha--) {
                int p = img.getRGB(izquierda, i);
                mirrorimgV.setRGB(derecha, i, p);
            }
        }
        img = mirrorimgV;
        Change();

    }
        break;//end case 3

    case 4://flip imagen horizontal
    {

        BufferedImage mirrorimgH = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);

        for (int i = 0; i < ancho; i++) {
            for (int arriba = 0, abajo = alto - 1; arriba < alto; arriba++, abajo--) {
                int p = img.getRGB(i, arriba);
                mirrorimgH.setRGB(i, abajo, p);
            }
        }
        img = mirrorimgH;
        Change();

    }
        break;//end case 4

    case 5: { //boton de reset

        //RESET
        File f = null;
        //leer image
        try {
            f = new File(ruta);
            rotate = false;
            zoomv = false;
            escalav = false;
            brillos = false;
            contrastes = false;
            undoDelete = false;
            undoIndex = 0;
            img = ImageIO.read(f);
        } catch (IOException e) {
            System.out.println(e);
        }

        Change();

    }
        break; //end case 5

    case 6: { //leer en formato binario

        FileNameExtensionFilter filter = new FileNameExtensionFilter("Image Files", "bmp");
        JFileChooser abrir = new JFileChooser();
        abrir.setFileSelectionMode(JFileChooser.FILES_ONLY);
        abrir.setFileFilter(filter);
        //abrir.setCurrentDirectory(new File(System.getProperty("user.home")));
        abrir.setCurrentDirectory(new File(System.getProperty("user.dir")));
        int result = abrir.showOpenDialog(inicio);
        if (result == JFileChooser.APPROVE_OPTION) {

            try {
                File selectedFile = abrir.getSelectedFile();
                ruta = selectedFile.getAbsolutePath();

                FileInputStream is = null;

                is = new FileInputStream(ruta);
                bmp.read(is);
                System.out.println("aqui");
                MemoryImageSource mis = bmp.crearImageSource();
                System.out.println("hola");
                Image im = Toolkit.getDefaultToolkit().createImage(mis);
                //Para poder colorcarlo en el label
                //Image image = createImage(new MemoryImageSource(bmp.crearImageSource()));
                BufferedImage newImage = new BufferedImage(im.getWidth(null), im.getHeight(null),
                        BufferedImage.TYPE_INT_RGB);
                //obtenemos la imagen que si se puede desplgar
                Graphics2D g = newImage.createGraphics();
                g.drawImage(im, 0, 0, null);
                g.dispose();

                img = newImage;
                rotate = false;
                zoomv = false;
                escalav = false;
                brillos = false;
                contrastes = false;
                undoDelete = false;
                undoIndex = 0;
                Change();

                //add img info
                inicio.setTitle("PDI: Tarea 3 -" + ruta);
                //dimensiones, profundidad de bits, Mb ocupados
                content = ("Size: " + (bmp.tamArchivo) / 1000 + "kb\nDimension: " + bmp.ancho + " x " + bmp.alto
                        + "\nBpp: " + bmp.bitsPorPixel + "bits");
                ancho = bmp.ancho;
                alto = bmp.alto;

            } catch (Exception ex) {
                Logger.getLogger(controlador.class.getName()).log(Level.SEVERE, null, ex);
            }

        } //end approval if
    }
        break; //end case 6

    //girar CW
    case 7: {

        BufferedImage new_Image = new BufferedImage(alto, ancho, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < ancho; i++) {
            for (int j = 0; j < alto; j++) {
                int p = img.getRGB(i, j);
                new_Image.setRGB(alto - j - 1, i, p);

            }
        }

        img = new_Image;
        Change();

    }
        break;//end case 7

    //girar CCW
    case 8: {

        BufferedImage new_Image = new BufferedImage(alto, ancho, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < ancho; i++) {
            for (int j = 0; j < alto; j++) {
                int p = img.getRGB(i, j);
                new_Image.setRGB(j, ancho - i - 1, p);

            }
        }

        img = new_Image;
        Change();

    }
        break;//end case 8

    case 9: { //Guardar Imagen

        FileNameExtensionFilter filter = new FileNameExtensionFilter("Image Files", "bmp");
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setFileFilter(filter);
        fileChooser.setDialogTitle("Save");
        fileChooser.setCurrentDirectory(new File(System.getProperty("user.home")));
        int userSelection = fileChooser.showSaveDialog(inicio);
        if (userSelection == JFileChooser.APPROVE_OPTION) {
            File fileToSave = fileChooser.getSelectedFile();
            System.out.println("Save as file: " + fileToSave.getAbsolutePath() + ".bmp");
            System.out.println("Save as: " + fileToSave.getName());
            bmp.saveMyLifeTonight(fileToSave, img);
        }
    }
        break;

    case 10: {
        //free rotation
        double anguloCartesiano = inicio.optionr;
        double aux;
        if (rotate == false) {
            original = img;
        }
        //para la ilusion de rotar sobre la "misma imagen"
        if (anguloCartesiano < 0) {

            aux = anguloCartesiano;
            anguloCartesiano = anguloCartesiano + angulo;
            angulo = anguloCartesiano;

        } else if (anguloCartesiano > 0) {

            aux = anguloCartesiano;
            anguloCartesiano = angulo + anguloCartesiano;
            angulo = anguloCartesiano;

        }

        anguloCartesiano = anguloCartesiano * Math.PI / 180;

        //CC coordinates
        int x, y;
        double distance, anguloPolar;
        int pisoX, techoX, pisoY, techoY;
        double rasterX, rasterY;
        // colores de los pixeles
        Color colorTL = null, colorTR, colorBL, colorBR = null;
        // interpolaciones
        double intX, intY;
        double rojoT, verdeT, azulT;
        double rojoB, verdeB, azulB;

        int centroX, centroY;

        centroX = original.getWidth() / 2;
        centroY = original.getHeight() / 2;

        BufferedImage imagenRotada = new BufferedImage(original.getWidth(), original.getHeight(),
                BufferedImage.TYPE_INT_ARGB);//fondo transparente

        for (int i = 0; i < original.getHeight(); ++i)
            for (int j = 0; j < original.getWidth(); ++j) {
                // convert raster to Cartesian
                x = j - centroX;
                y = centroY - i;

                // convert Cartesian to polar
                distance = Math.sqrt(x * x + y * y);
                anguloPolar = 0.0;
                if (x == 0) {
                    if (y == 0) {
                        // centre of image, no rotation needed
                        imagenRotada.setRGB(j, i, original.getRGB(j, i));

                        continue;
                    } else if (y < 0)
                        anguloPolar = 1.5 * Math.PI;
                    else
                        anguloPolar = 0.5 * Math.PI;
                } else
                    anguloPolar = Math.atan2((double) y, (double) x);

                // 
                anguloPolar -= anguloCartesiano;

                //polr a carte
                rasterX = distance * Math.cos(anguloPolar);
                rasterY = distance * Math.sin(anguloPolar);

                // cartesiano a raster
                rasterX = rasterX + (double) centroX;
                rasterY = (double) centroY - rasterY;

                pisoX = (int) (Math.floor(rasterX));
                pisoY = (int) (Math.floor(rasterY));
                techoX = (int) (Math.ceil(rasterX));
                techoY = (int) (Math.ceil(rasterY));

                // check bounds /// AQUIWWIUEI
                if (pisoX < 0 || techoX < 0 || pisoX >= original.getWidth() || techoX >= original.getWidth()
                        || pisoY < 0 || techoY < 0 || pisoY >= original.getHeight()
                        || techoY >= original.getHeight())
                    continue;

                intX = rasterX - (double) pisoX;
                intY = rasterY - (double) pisoY;

                colorTL = new Color(original.getRGB(pisoX, pisoY));
                colorTR = new Color(original.getRGB(techoX, pisoY));
                colorBL = new Color(original.getRGB(pisoX, techoY));
                colorBR = new Color(original.getRGB(techoX, techoY));

                // interpolacion horizontal top
                rojoT = (1 - intX) * colorTL.getRed() + intX * colorTR.getRed();
                verdeT = (1 - intX) * colorTL.getGreen() + intX * colorTR.getGreen();
                azulT = (1 - intX) * colorTL.getBlue() + intX * colorTR.getBlue();
                // interpolacion horizontal bot
                rojoB = (1 - intX) * colorBL.getRed() + intX * colorBR.getRed();
                verdeB = (1 - intX) * colorBL.getGreen() + intX * colorBR.getGreen();
                azulB = (1 - intX) * colorBL.getBlue() + intX * colorBR.getBlue();
                // interpolacion vertical
                int p = original.getRGB(j, i);
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;
                r = truncate(Math.round((1 - intY) * rojoT + intY * rojoB));
                g = truncate(Math.round((1 - intY) * verdeT + intY * verdeB));
                b = truncate(Math.round((1 - intY) * azulT + intY * azulB));
                p = (a << 24) | (r << 16) | (g << 8) | b;
                imagenRotada.setRGB(j, i, p);

            }
        img = imagenRotada;
        rotate = true;
        inicio.jLabel3.setBounds(0, 0, ancho, alto);
        ImageIcon icon = new ImageIcon(img);
        inicio.jLabel3.setIcon(icon);

    }
        break; //case 10

    case 11: { //histogram

        //para recorrer todos los valores y obtener los samples
        /*
        for (y) {
            for (x) {
               pixel = raster.getDataElements(x, y, pixel);
            }
        }
                            */
        int BINS = 256;
        HistogramDataset dataset = new HistogramDataset();
        Raster raster = img.getRaster();

        double[] r = new double[ancho * alto];
        ChartPanel panelB = null;
        ChartPanel panelG = null;
        ChartPanel panelR = null;
        ChartPanel panel;

        if (bmp.bitsPorPixel == 1) {

            r = raster.getSamples(0, 0, ancho, alto, 0, r);
            ColorModel ColorM = img.getColorModel();

            dataset.addSeries("Grey", r, BINS);

            //de aqui para abajo es el plotting
            // chart all
            JFreeChart chart = ChartFactory.createHistogram("Histogram", "Value", "Count", dataset,
                    PlotOrientation.VERTICAL, true, true, false);
            XYPlot plot = (XYPlot) chart.getPlot();
            XYBarRenderer renderer = (XYBarRenderer) plot.getRenderer();
            renderer.setBarPainter(new StandardXYBarPainter());

            Paint[] paintArray = { new Color(0x80ff0000, true) };
            plot.setDrawingSupplier(
                    new DefaultDrawingSupplier(paintArray, DefaultDrawingSupplier.DEFAULT_FILL_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
            panel = new ChartPanel(chart);
            panel.setMouseWheelEnabled(true);

        } else {

            r = raster.getSamples(0, 0, ancho, alto, 0, r);
            dataset.addSeries("Red", r, BINS);
            r = raster.getSamples(0, 0, ancho, alto, 1, r);
            dataset.addSeries("Green", r, BINS);
            r = raster.getSamples(0, 0, ancho, alto, 2, r);
            dataset.addSeries("Blue", r, BINS);

            //de aqui para abajo es el plotting
            // chart all
            JFreeChart chart = ChartFactory.createHistogram("Histogram", "Value", "Count", dataset,
                    PlotOrientation.VERTICAL, true, true, false);
            XYPlot plot = (XYPlot) chart.getPlot();
            XYBarRenderer renderer = (XYBarRenderer) plot.getRenderer();
            renderer.setBarPainter(new StandardXYBarPainter());
            // translucent red, green & blue
            Paint[] paintArray = { new Color(0x80ff0000, true), new Color(0x8000ff00, true),
                    new Color(0x800000ff, true) };
            plot.setDrawingSupplier(
                    new DefaultDrawingSupplier(paintArray, DefaultDrawingSupplier.DEFAULT_FILL_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
            panel = new ChartPanel(chart);
            panel.setMouseWheelEnabled(true);

            //CHART Red
            HistogramDataset datasetR = new HistogramDataset();
            r = raster.getSamples(0, 0, ancho, alto, 0, r);
            datasetR.addSeries("Red", r, BINS);
            JFreeChart chartR = ChartFactory.createHistogram("Histogram B", "Value", "Count", datasetR,
                    PlotOrientation.VERTICAL, true, true, false);
            XYPlot plotR = (XYPlot) chartR.getPlot();
            XYBarRenderer rendererR = (XYBarRenderer) plotR.getRenderer();
            rendererR.setBarPainter(new StandardXYBarPainter());
            // translucent red, green & blue
            Paint[] paintArrayR = { new Color(0x80ff0000, true)

            };
            plotR.setDrawingSupplier(
                    new DefaultDrawingSupplier(paintArrayR, DefaultDrawingSupplier.DEFAULT_FILL_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
            panelR = new ChartPanel(chartR);
            panelR.setMouseWheelEnabled(true);

            //CHART GREEN

            HistogramDataset datasetG = new HistogramDataset();
            r = raster.getSamples(0, 0, ancho, alto, 1, r);
            datasetG.addSeries("Green", r, BINS);
            JFreeChart chartG = ChartFactory.createHistogram("Histogram G ", "Value", "Count", datasetG,
                    PlotOrientation.VERTICAL, true, true, false);
            XYPlot plotG = (XYPlot) chartG.getPlot();
            XYBarRenderer rendererG = (XYBarRenderer) plotG.getRenderer();
            rendererG.setBarPainter(new StandardXYBarPainter());
            // translucent red, green & blue
            Paint[] paintArrayG = { new Color(0x8000ff00, true)

            };
            plotG.setDrawingSupplier(
                    new DefaultDrawingSupplier(paintArrayG, DefaultDrawingSupplier.DEFAULT_FILL_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
            panelG = new ChartPanel(chartG);
            panelG.setMouseWheelEnabled(true);

            //CHART BLUE

            HistogramDataset datasetB = new HistogramDataset();
            r = raster.getSamples(0, 0, ancho, alto, 2, r);
            datasetB.addSeries("Blue", r, BINS);
            JFreeChart chartB = ChartFactory.createHistogram("Histogram B ", "Value", "Count", datasetB,
                    PlotOrientation.VERTICAL, true, true, false);
            XYPlot plotB = (XYPlot) chartB.getPlot();
            XYBarRenderer rendererB = (XYBarRenderer) plotB.getRenderer();
            rendererB.setBarPainter(new StandardXYBarPainter());
            // translucent red, green & blue
            Paint[] paintArrayB = { new Color(0x800000ff, true)

            };
            plotB.setDrawingSupplier(
                    new DefaultDrawingSupplier(paintArrayB, DefaultDrawingSupplier.DEFAULT_FILL_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_PAINT_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
                            DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
            panelB = new ChartPanel(chartB);
            panelB.setMouseWheelEnabled(true);

        }

        //JTabbedPane jtp=new JTabbedPane();
        if (!viewH) {

            inicio.jTabbedPane1.addTab("Histogram", panel);
            inicio.jTabbedPane1.addTab("Histogram R", panelR);
            inicio.jTabbedPane1.addTab("Histogram G", panelG);
            inicio.jTabbedPane1.addTab("Histogram B", panelB);
            viewH = true;
        } else {
            inicio.jTabbedPane1.remove(inicio.jTabbedPane1.indexOfTab("Histogram"));
            inicio.jTabbedPane1.remove(inicio.jTabbedPane1.indexOfTab("Histogram R"));
            inicio.jTabbedPane1.remove(inicio.jTabbedPane1.indexOfTab("Histogram G"));
            inicio.jTabbedPane1.remove(inicio.jTabbedPane1.indexOfTab("Histogram B"));
            viewH = false;
        }

    }
        break;

    case 12: {
        //BRILLO
        int dif = inicio.brillo;

        if (brillos == false) {
            original = img;
        }
        int ancho = img.getWidth();
        int alto = img.getHeight();
        //se crea un buffer
        BufferedImage brillito = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        //se convierten los colores a negativo y se va guardando en el buffer
        for (int y = 0; y < alto; y++) {
            for (int x = 0; x < ancho; x++) {
                int p = original.getRGB(x, y);
                //obtenemos el valor r g b a de cada pixel
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;
                //se resta el rbg
                r = truncate(r + dif);
                g = truncate(g + dif);
                b = truncate(b + dif);
                //se guarda el rgb
                p = (r << 16) | (g << 8) | b;
                brillito.setRGB(x, y, p);
            }
        }
        img = brillito;
        brillos = true;
        inicio.jLabel3.setBounds(0, 0, ancho, alto);
        ImageIcon icon = new ImageIcon(img);
        inicio.jLabel3.setIcon(icon);

    }
        break; //end case 12

    case 13: {
        //CONTRAST
        double dif = inicio.contraste;
        double level = Math.pow(((100.0 + dif) / 100.0), 2.0);

        if (contrastes == false) {
            original = img;
        }
        int ancho = original.getWidth();
        int alto = original.getHeight();
        BufferedImage contraste = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);

        for (int y = 0; y < alto; y++) {
            for (int x = 0; x < ancho; x++) {
                int p = original.getRGB(x, y);
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;

                b = truncate((int) ((((((double) b / 255.0) - 0.5) * level) + 0.5) * 255.0));
                g = truncate((int) ((((((double) g / 255.0) - 0.5) * level) + 0.5) * 255.0));
                r = truncate((int) ((((((double) r / 255.0) - 0.5) * level) + 0.5) * 255.0));

                p = (r << 16) | (g << 8) | b;
                contraste.setRGB(x, y, p);
            }
        }
        img = contraste;
        contrastes = true;
        inicio.jLabel3.setBounds(0, 0, ancho, alto);
        ImageIcon icon = new ImageIcon(img);
        inicio.jLabel3.setIcon(icon);

    }
        break;// case 13

    case 14: {
        //UMBRALIZACION
        double u = inicio.umbral;
        if (inicio.jCheckBox1.isSelected()) {

            int ancho = img.getWidth();
            int alto = img.getHeight();

            BufferedImage contraste = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);

            for (int y = 0; y < alto; y++) {
                for (int x = 0; x < ancho; x++) {
                    int p = img.getRGB(x, y);

                    int a = (p >> 24) & 0xff;
                    int r = (p >> 16) & 0xff;
                    int g = (p >> 8) & 0xff;
                    int b = p & 0xff;

                    double mediana = (double) (r + b + g);
                    mediana /= 3;
                    int med = (int) Math.round(mediana);

                    b = med;
                    g = med;
                    r = med;

                    if (r <= u)
                        r = 0;
                    else
                        r = 255;

                    if (g <= u)
                        g = 0;
                    else
                        g = 255;

                    if (b <= u)
                        b = 0;
                    else
                        b = 255;

                    p = (r << 16) | (g << 8) | b;
                    contraste.setRGB(x, y, p);
                }
            }
            img = contraste;
            Change();
        }

    }
        break;

    case 15: {
        BufferedImage equalized = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        int r, g, b, a;
        int pixel = 0;

        //look up table rgb 
        int[] rhist = new int[256];
        int[] ghist = new int[256];
        int[] bhist = new int[256];

        for (int i = 0; i < rhist.length; i++)
            rhist[i] = 0;
        for (int i = 0; i < ghist.length; i++)
            ghist[i] = 0;
        for (int i = 0; i < bhist.length; i++)
            bhist[i] = 0;

        for (int i = 0; i < img.getWidth(); i++) {
            for (int j = 0; j < img.getHeight(); j++) {

                int red = new Color(img.getRGB(i, j)).getRed();
                int green = new Color(img.getRGB(i, j)).getGreen();
                int blue = new Color(img.getRGB(i, j)).getBlue();
                rhist[red]++;
                ghist[green]++;
                bhist[blue]++;

            }
        }

        //histograma color
        ArrayList<int[]> imageHist = new ArrayList<int[]>();
        imageHist.add(rhist);
        imageHist.add(ghist);
        imageHist.add(bhist);
        //lookup table
        ArrayList<int[]> imgLT = new ArrayList<int[]>();
        // llenar 
        rhist = new int[256];
        ghist = new int[256];
        bhist = new int[256];

        for (int i = 0; i < rhist.length; i++)
            rhist[i] = 0;
        for (int i = 0; i < ghist.length; i++)
            ghist[i] = 0;
        for (int i = 0; i < bhist.length; i++)
            bhist[i] = 0;

        long rojosT = 0;
        long verdesT = 0;
        long azulT = 0;

        // 
        float factorDeEscala = (float) (255.0 / (ancho * alto));

        for (int i = 0; i < rhist.length; i++) {
            rojosT += imageHist.get(0)[i];
            int valor = (int) (rojosT * factorDeEscala);
            if (valor > 255) {
                rhist[i] = 255;
            } else
                rhist[i] = valor;

            verdesT += imageHist.get(1)[i];
            int valg = (int) (verdesT * factorDeEscala);
            if (valg > 255) {
                ghist[i] = 255;
            } else
                ghist[i] = valg;

            azulT += imageHist.get(2)[i];
            int valb = (int) (azulT * factorDeEscala);
            if (valb > 255) {
                bhist[i] = 255;
            } else
                bhist[i] = valb;
        }

        imgLT.add(rhist);
        imgLT.add(ghist);
        imgLT.add(bhist);

        for (int i = 0; i < ancho; i++) {
            for (int j = 0; j < alto; j++) {

                // colores
                a = new Color(img.getRGB(i, j)).getAlpha();
                r = new Color(img.getRGB(i, j)).getRed();
                g = new Color(img.getRGB(i, j)).getGreen();
                b = new Color(img.getRGB(i, j)).getBlue();

                // nuevos valoooooores
                r = imgLT.get(0)[r];
                g = imgLT.get(1)[g];
                b = imgLT.get(2)[b];

                // rgb otra vez
                pixel = colorToRGB(a, r, g, b);

                //imagen final
                equalized.setRGB(i, j, pixel);

            }
        }

        img = equalized;
        Change();

    }
        break;

    case 16: {
        //zoom 
        double du = inicio.zoom;
        double u = du / 100;

        if (zoomv == false) {
            original = img;
        }
        BufferedImage zoom = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);

        for (int i = 0; i < zoom.getHeight(); ++i)
            for (int j = 0; j < zoom.getWidth(); ++j) {
                //nearest
                if (tipo == 1) {

                    int ax = (int) (Math.floor(i / u));
                    int ay = (int) (Math.floor(j / u));

                    int p = original.getRGB(ax, ay);
                    zoom.setRGB(i, j, p);
                }

                //bilinear
                if (tipo == 2) {

                }

                //no loss
                if (tipo == 0) {

                    int ax = (int) (i / u);
                    int ay = (int) (j / u);

                    int p = original.getRGB(ax, ay);
                    zoom.setRGB(i, j, p);
                }

            }
        img = zoom;
        zoomv = true;
        inicio.jLabel3.setBounds(0, 0, ancho, alto);
        ImageIcon icon = new ImageIcon(img);
        inicio.jLabel3.setIcon(icon);

    }
        break;

    case 17: {
        //escala
        double du = inicio.escala;
        double u = du / 100;

        if (escalav == false) {
            original = img;
        }
        int escalaX = (int) (ancho * u);
        int escalaY = (int) (alto * u);
        BufferedImage escala = new BufferedImage(escalaX, escalaY, BufferedImage.TYPE_INT_RGB);

        for (int i = 0; i < escala.getHeight(); ++i)
            for (int j = 0; j < escala.getWidth(); ++j) {
                //R(x,y):= A(x/ax, y/ay) 
                //R(x,y):= A(Floor x/10 ,Floor /10)

                //nearest
                if (tipo == 1) {

                    int ax = (int) (Math.floor(i / u));
                    int ay = (int) (Math.floor(j / u));

                    int p = original.getRGB(ax, ay);
                    escala.setRGB(i, j, p);
                }

                //bilinear
                if (tipo == 2) {

                }

                //no loss
                if (tipo == 0) {

                    int ax = (int) (i / u);
                    int ay = (int) (j / u);

                    int p = original.getRGB(ax, ay);
                    escala.setRGB(i, j, p);
                }

            }

        img = escala;
        escalav = true;
        inicio.jLabel3.setBounds(0, 0, ancho, alto);
        ImageIcon icon = new ImageIcon(img);
        inicio.jLabel3.setIcon(icon);
        content = ("Dimension: " + img.getWidth() + " x " + img.getHeight() + "\nBpp: " + bmp.bitsPorPixel
                + "bits");

    }
        break;

    case 18://prewitt both
    {

        BufferedImage aux = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        aux = img;
        BufferedImage y, x;

        float[][] arraya = { { -1, 0, 1 }, { -1, 0, 1 }, { -1, 0, 1 } };
        float[][] arrayb = { { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 },
                { -2, -1, 0, 1, 2 }, };

        float[][] arrayc = { { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 },
                { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 },
                { -3, -2, -1, 0, 1, 2, 3 }, };

        float[][] array = { { -1, -1, -1 }, { 0, 0, 0 }, { 1, 1, 1 } };
        float[][] array2 = { { -2, -2, -2, -2, -2 }, { -1, -1, -1, -1, -1 }, { 0, 0, 0, 0, 0 },
                { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 }, };
        float[][] array3 = { { -3, -3, -3, -3, -3, -3, -3 }, { -2, -2, -2, -2, -2, -2, -2 },
                { -1, -1, -1, -1, -1, -1, -1 }, { 0, 0, 0, 0, 0, 0, 0 }, { 1, 1, 1, 1, 1, 1, 1 },
                { 2, 2, 2, 2, 2, 2, 2 }, { 3, 3, 3, 3, 3, 3, 3 }, };
        if (inicio.size == 7) {
            y = generalKernel(array3, 7);
            img = aux;
            x = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(array2, 5);
            img = aux;
            x = generalKernel(arrayb, 5);
        } else {
            y = generalKernel(array, 3);
            img = aux;
            x = generalKernel(arraya, 3);
        }

        for (int i = 0; i < ancho; i++) {
            for (int j = 0; j < alto; j++) {

                int p = x.getRGB(i, j);
                int p2 = y.getRGB(i, j);
                //obtenemos el valor r g b a de cada pixel

                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;

                int r2 = (p2 >> 16) & 0xff;
                int g2 = (p2 >> 8) & 0xff;
                int b2 = p2 & 0xff;
                //process
                int resR = truncate(Math.sqrt(Math.pow(r, 2) + Math.pow(r2, 2)));
                int resG = truncate(Math.sqrt(Math.pow(g, 2) + Math.pow(g2, 2)));
                int resB = truncate(Math.sqrt(Math.pow(b, 2) + Math.pow(b2, 2)));

                //se guarda el rgb
                p = (resR << 16) | (resG << 8) | resB;
                img.setRGB(i, j, p);

            }
            Change();
        }
    }
        break;

    case 19://prewitt x
    {

        BufferedImage x;

        float[][] arraya = { { -1, 0, 1 }, { -1, 0, 1 }, { -1, 0, 1 } };
        float[][] arrayb = { { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 }, { -2, -1, 0, 1, 2 },
                { -2, -1, 0, 1, 2 }, };

        float[][] arrayc = { { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 },
                { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 }, { -3, -2, -1, 0, 1, 2, 3 },
                { -3, -2, -1, 0, 1, 2, 3 }, };

        if (inicio.size == 7) {
            x = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            x = generalKernel(arrayb, 5);
        } else {
            x = generalKernel(arraya, 3);
        }
        img = x;
        Change();

    }
        break;

    case 20://prewitt y
    {

        BufferedImage y;

        float[][] array = { { -1, -1, -1 }, { 0, 0, 0 }, { 1, 1, 1 } };
        float[][] array2 = { { -2, -2, -2, -2, -2 }, { -1, -1, -1, -1, -1 }, { 0, 0, 0, 0, 0 },
                { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 }, };
        float[][] array3 = { { -3, -3, -3, -3, -3, -3, -3 }, { -2, -2, -2, -2, -2, -2, -2 },
                { -1, -1, -1, -1, -1, -1, -1 }, { 0, 0, 0, 0, 0, 0, 0 }, { 1, 1, 1, 1, 1, 1, 1 },
                { 2, 2, 2, 2, 2, 2, 2 }, { 3, 3, 3, 3, 3, 3, 3 }, };

        if (inicio.size == 7) {
            y = generalKernel(array3, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(array2, 5);
        } else {
            y = generalKernel(array, 3);
        }

        img = y;
        Change();

    }
        break;

    case 21://Sobel x
    {

        BufferedImage x;
        float[][] arraya = { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } };

        float[][] arrayb = { { -5, -4, 0, 4, 5 }, { -8, -10, 0, 10, 8 }, { -10, -20, 0, 20, 10 },
                { -8, -10, 0, 10, 8 }, { -5, -4, 0, 4, 5 }, };

        float[][] arrayc = { { 3, 2, 1, 0, -1, -2, -3 }, { 4, 3, 2, 0, -2, -3, -4 }, { 5, 4, 3, 0, -3, -4, -5 },
                { 6, 5, 4, 0, -4, -5, -6 }, { 5, 4, 3, 0, -3, -4, -5 }, { 4, 3, 2, 0, -2, -3, -4 },
                { 3, 2, 1, 0, -1, -2, -3 }, };

        if (inicio.size == 7) {
            x = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            x = generalKernel(arrayb, 5);
        } else {
            x = generalKernel(arraya, 3);
        }
        img = x;
        Change();

    }
        break;

    case 22://sobel y
    {

        BufferedImage y;

        float[][] array1 = { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } };

        float[][] array2 = { { 5, 8, 10, 8, 5 }, { 4, 10, 20, 10, 4 }, { 0, 0, 0, 0, 0 },
                { -4, -10, -20, -10, -4 }, { -5, -8, -10, -8, -5 }, };

        float[][] array3 = { { 3, 4, 5, 6, 5, 4, 3 }, { 2, 3, 4, 5, 4, 3, 2 }, { 1, 2, 3, 4, 3, 2, 1 },
                { 0, 0, 0, 0, 0, 0, 0 }, { -1, -2, -3, -4, -3, -2, -1 }, { -2, -3, -4, -5, -4, -3, -2 },
                { -3, -4, -5, -6, -5, -4, -3 }, };

        if (inicio.size == 7) {
            y = generalKernel(array3, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(array2, 5);
        } else {
            y = generalKernel(array1, 3);
        }

        img = y;
        Change();

    }
        break;

    case 23://sobel both
    {

        BufferedImage aux = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
        aux = img;
        BufferedImage y, x;

        float[][] arraya = { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } };

        float[][] arrayb = { { -5, -4, 0, 4, 5 }, { -8, -10, 0, 10, 8 }, { -10, -20, 0, 20, 10 },
                { -8, -10, 0, 10, 8 }, { -5, -4, 0, 4, 5 }, };

        float[][] arrayc = { { 3, 2, 1, 0, -1, -2, -3 }, { 4, 3, 2, 0, -2, -3, -4 }, { 5, 4, 3, 0, -3, -4, -5 },
                { 6, 5, 4, 0, -4, -5, -6 }, { 5, 4, 3, 0, -3, -4, -5 }, { 4, 3, 2, 0, -2, -3, -4 },
                { 3, 2, 1, 0, -1, -2, -3 }, };

        float[][] array1 = { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } };

        float[][] array2 = { { 5, 8, 10, 8, 5 }, { 4, 10, 20, 10, 4 }, { 0, 0, 0, 0, 0 },
                { -4, -10, -20, -10, -4 }, { -5, -8, -10, -8, -5 }, };

        float[][] array3 = { { 3, 4, 5, 6, 5, 4, 3 }, { 2, 3, 4, 5, 4, 3, 2 }, { 1, 2, 3, 4, 3, 2, 1 },
                { 0, 0, 0, 0, 0, 0, 0 }, { -1, -2, -3, -4, -3, -2, -1 }, { -2, -3, -4, -5, -4, -3, -2 },
                { -3, -4, -5, -6, -5, -4, -3 }, };
        if (inicio.size == 7) {
            y = generalKernel(array3, 7);
            img = aux;
            x = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(array2, 5);
            img = aux;
            x = generalKernel(arrayb, 5);
        } else {
            y = generalKernel(array1, 3);
            img = aux;
            x = generalKernel(arraya, 3);
        }

        for (int i = 0; i < ancho; i++) {
            for (int j = 0; j < alto; j++) {

                int p = x.getRGB(i, j);
                int p2 = y.getRGB(i, j);
                //obtenermos el valor r g b a de cada pixel

                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;

                int r2 = (p2 >> 16) & 0xff;
                int g2 = (p2 >> 8) & 0xff;
                int b2 = p2 & 0xff;
                //process
                int resR = truncate(Math.sqrt(Math.pow(r, 2) + Math.pow(r2, 2)));
                int resG = truncate(Math.sqrt(Math.pow(g, 2) + Math.pow(g2, 2)));
                int resB = truncate(Math.sqrt(Math.pow(b, 2) + Math.pow(b2, 2)));

                //se guarda el rgb
                p = (resR << 16) | (resG << 8) | resB;
                img.setRGB(i, j, p);

            }
            Change();
        }
    }
        break;

    case 24://Gauss 
    {

        BufferedImage y;

        float[][] arraya = { { 1 / 16f, 1 / 8f, 1 / 16f }, { 1 / 8f, 1 / 4f, 1 / 8f },
                { 1 / 16f, 1 / 8f, 1 / 16f }, };
        float[][] arrayb = { { 1 / 273f, 4 / 273f, 7 / 273f, 4 / 273f, 1 / 273f },
                { 4 / 273f, 16 / 273f, 26 / 273f, 16 / 273f, 4 / 273f },
                { 7 / 273f, 26 / 273f, 41 / 273f, 26 / 273f, 7 / 273f },
                { 4 / 273f, 16 / 273f, 26 / 273f, 16 / 273f, 4 / 273f },
                { 1 / 273f, 4 / 273f, 7 / 273f, 4 / 273f, 1 / 273f }, };

        float[][] arrayc = {
                { 0.00000067f, 0.00002292f, 0.00019117f, 0.00038771f, 0.00019117f, 0.00002292f, 0.00000067f },
                { 0.00002292f, 0.00078634f, 0.00655965f, 0.01330373f, 0.00655965f, 0.00078633f, 0.00002292f },
                { 0.00019117f, 0.00655965f, 0.05472157f, 0.11098164f, 0.05472157f, 0.00655965f, 0.00019117f },
                { 0.00038771f, 0.01330373f, 0.11098164f, 0.22508352f, 0.11098164f, 0.01330373f, 0.00038771f },
                { 0.00019117f, 0.00655965f, 0.05472157f, 0.11098164f, 0.05472157f, 0.00655965f, 0.00019117f },
                { 0.00002292f, 0.00078634f, 0.00655965f, 0.01330373f, 0.00655965f, 0.00078633f, 0.00002292f },
                { 0.00000067f, 0.00002292f, 0.00019117f, 0.00038771f, 0.00019117f, 0.00002292f, 0.00000067f } };

        if (inicio.size == 7) {
            y = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(arrayb, 5);
        } else {
            y = generalKernel(arraya, 3);
        }

        img = y;
        Change();

    }
        break;

    case 25: {

        BufferedImage y;

        float[][] arraya = { { 1 / 9f, 1 / 9f, 1 / 9f }, { 1 / 9f, 1 / 9f, 1 / 9f },
                { 1 / 9f, 1 / 9f, 1 / 9f }, };
        float[][] arrayb = { { 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f },
                { 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f },
                { 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f },
                { 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f },
                { 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f, 1 / 25f }, };
        float[][] arrayc = { { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f },
                { 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f, 1 / 49f }, };
        if (inicio.size == 7) {
            y = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(arrayb, 5);
        } else {
            y = generalKernel(arraya, 3);
        }

        img = y;
        Change();

    }
        break;

    case 26://sharpen 
    {

        BufferedImage y;

        float[][] arraya = { { -1, -1, -1 }, { -1, 9, -1 }, { -1, -1, -1 }, };
        float[][] arrayb = { { -1, -1, -1, -1, -1 }, { -1, -1, -1, -1, -1 }, { -1, -1, 26, -1, -1 },
                { -1, -1, -1, -1, -1 }, { -1, -1, -1, -1, -1 }, };
        float[][] arrayc = { { -1, -1, -1, -1, -1, -1, -1 }, { -1, -2, -2, -2, -2, -2, -1 },
                { -1, -2, -3, -3, -3, -2, -1 }, { -1, -2, -3, 81, -3, -2, -1 }, { -1, -2, -3, -3, -3, -2, -1 },
                { -1, -2, -2, -2, -2, -2, -1 }, { -1, -1, -1, -1, -1, -1, -1 }, };
        if (inicio.size == 7) {
            y = generalKernel(arrayc, 7);
        } else if (inicio.size == 5) {
            y = generalKernel(arrayb, 5);
        } else {
            y = generalKernel(arraya, 3);
        }

        img = y;
        Change();

    }
        break;
    case 27: {

        kernel = new Kernel();
        kernel.show();
        kernel.setTitle("Kernel");
        kernel.setVisible(true);
        kernel.setLocationRelativeTo(null);
        kernel.setResizable(false);
        kernel.pack();

    }
        break;

    case 28: //valores
    {

        float[][] floatdata = new float[kernel.dim][kernel.dim];
        for (int i = 0; i < kernel.dim; i++) {
            for (int j = 0; j < kernel.dim; j++) {
                floatdata[i][j] = floatValue(kernel.tableData[i][j]);
            }
        }
        kernel.dispose();
        BufferedImage y;
        y = generalKernel(floatdata, kernel.dim);
        img = y;

        Change();

    }
        break;

    case 29://motion blur
    {
        BufferedImage y;

        float[][] array = { { 1 / 9f, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 1 / 9f, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 1 / 9f, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1 / 9f, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 1 / 9f, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 1 / 9f, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 1 / 9f, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1 / 9f, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 1 / 9f }, };

        /*
        float[][] arrayb = {
            {1/3f, 0, 0},
            {0, 1/3f, 0},
            {0, 0, 1/3f},
         };*/

        y = generalKernel(array, 9);

        img = y;
        Change();

    }
        break;

    } //end switch

}