예제 #1
1
파일: CA.java 프로젝트: jkwhite/nausicaa
 public int[] getBlock(int[] into, int x, int y, int dx, int dy, int offset) {
   return _i.getRGB(x, y, dx, dy, into, offset, 0);
 }
예제 #2
0
파일: Picture.java 프로젝트: rafacb/MasLab
 static BufferedImage addMagnitudes(BufferedImage img1, BufferedImage img2) {
   BufferedImage dst = new BufferedImage(img1.getWidth(), img1.getHeight(), img1.getType());
   for (int y = 0; y < img1.getHeight(); ++y) {
     for (int x = 0; x < img1.getWidth(); ++x) {
       int rgb1 = img1.getRGB(x, y);
       int rgb2 = img2.getRGB(x, y);
       int r1 = (rgb1 & 0x00FF0000) >> 16;
       int r2 = (rgb2 & 0x00FF0000) >> 16;
       int r = (int) (Math.sqrt(r1 * r1 + r2 * r2) / Math.sqrt(2.0));
       if (r > 255) r = 255;
       if (r < 0) r = 0;
       int g1 = (rgb1 & 0x0000FF00) >> 8;
       int g2 = (rgb2 & 0x0000FF00) >> 8;
       int g = (int) (Math.sqrt(g1 * g1 + g2 * g2) / Math.sqrt(2.0));
       if (g > 255) g = 255;
       if (g < 0) g = 0;
       int b1 = rgb1 & 0x000000FF;
       int b2 = rgb2 & 0x000000FF;
       int b = (int) (Math.sqrt(b1 * b1 + b2 * b2) / Math.sqrt(2.0));
       if (b > 255) b = 255;
       if (b < 0) b = 0;
       int rgb = b + (g << 8) + (r << 16);
       dst.setRGB(x, y, rgb);
     }
   }
   return dst;
 }
  public static int[] decodeImage(BufferedImage img) {
    /* finds the hidden values in the text file */

    int[] a_b, a, b;
    a = new int[8];
    b = new int[8];
    a_b = new int[2];
    int i;

    for (i = 0; i < a.length; i++) {
      int p = img.getRGB(i, i);
      int[] bin = convertToBinary(p, 32);
      a[i] = bin[0];
    }

    for (; i < (a.length + b.length); i++) {
      int p = img.getRGB(i, i);
      int[] bin = convertToBinary(p, 32);
      b[i - b.length] = bin[0];
    }

    a_b[0] = convertToDigit(a, 8);
    a_b[1] = convertToDigit(b, 8);

    return a_b;
  }
예제 #4
0
  /** Prototype give player a leveled up look */
  public void Opify(double Fac) {

    for (int i = 0; i < imgCHARAC.getWidth(); i++) {
      for (int j = 0; j < imgCHARAC.getHeight(); j++) {
        if (imgCHARAC.getRGB(i, j) != imgCHARAC.getRGB(2, 2)) {
          imgCHARAC.setRGB(i, j, (int) Math.round(imgCHARAC.getRGB(i, j) * Fac));
        }
      }
    }
  }
  public static BufferedImage encodeImage(String filename, int[] primes) {
    /* encodes a and b in the image using a sequence.
     * We are assuming that the image would be big enough
     * to hold the 16 bits
     */

    BufferedImage img, newimg = null;
    int[] a = convertToBinary(primes[0], 8);
    int[] b = convertToBinary(primes[1], 8);
    int[] a_b = copyBits(a, b); // copy all bits into one array

    try {
      img = ImageIO.read(new File(imagePath + filename));
      for (int i = 0; i < a_b.length; i++) {
        int p = img.getRGB(i, i);
        int[] bin = convertToBinary(p, 32);
        bin[0] = a_b[i];
        int d = convertToDigit(bin, 32);
        img.setRGB(i, i, d);
      }
      ImageIO.write(img, "png", new File(imagePath + "new_" + filename));
      newimg = ImageIO.read(new File(imagePath + "new_" + filename));
    } catch (IOException e) {
      System.out.println("ERROR WRITING IMAGE...\n" + e.toString());
      System.exit(1);
    }

    return newimg;
  }
예제 #6
0
  public Color getColorAt(int x, int y) {
    int col = img.getRGB(x, y);
    int r = col >> 16 & 0xff;
    int g = col >> 8 & 0xff;
    int b = col & 0xff;

    return new Color(r, g, b);
  }
예제 #7
0
파일: CA.java 프로젝트: jkwhite/nausicaa
 private void writeObject(java.io.ObjectOutputStream out) throws IOException {
   out.writeFloat(_goodness);
   out.writeInt(getWidth());
   out.writeInt(getHeight());
   int[] row = new int[getWidth()];
   for (int y = 0; y < getHeight(); y++) {
     _i.getRGB(0, y, row.length, 1, row, 0, 0);
     out.writeObject(row);
   }
 }
예제 #8
0
 public void drawTileNumC(int tileNum, int x, int y, Color c, Graphics g) {
   BufferedImage coloredTile = tiles[tileNum];
   for (int i = 0; i < this.tW; i++) {
     for (int j = 0; j < this.tH; j++) {
       Color originalColor = new Color(coloredTile.getRGB(i, j), true);
       Color nc = new Color(c.getRed(), c.getGreen(), c.getBlue(), originalColor.getAlpha());
       coloredTile.setRGB(i, j, nc.getRGB());
     }
   }
   g.drawImage(tiles[tileNum], x, y, null);
 }
예제 #9
0
  /**
   * do damage to character
   *
   * @param Dmg Amount of Damage
   */
  public void Damage(int Dmg, int Type) {
    // If character is already dead then dont do damage
    if (ISDEAD) return;

    // Do damage
    if (Type == 1) {
      // DAMAGE FROM PHYSICAL ATTACK
      if (STATS.ARMOR > Dmg) return;
      HEALTH = HEALTH - Dmg + STATS.ARMOR;
    } else if (Type == 2) {
      // DAMAGE FROM MAGIC ATTACK
      if (STATS.MAGIC_RESIST > Dmg) return;
      HEALTH = HEALTH - Dmg + STATS.MAGIC_RESIST;
    }
    // If an Npc then run and hide
    if (NAI != null) {
      NAI.State = "alarmed";
    }

    // Death condition
    if (HEALTH <= 0) {
      // If player is dead
      if (this.CLASS.equals("Player")) {

        HEALTH = 0;

        // Quit game
        JOptionPane.showMessageDialog(null, "You are dead");
        X = 100;
        Y = 100;
        Opify(50);
        HEALTH = (int) MAX_HEALTH;

      } else {
        // If other character
        // set Death stats
        ISDEAD = true;
        HEALTH = 0;
        // display death
        CLASS = Cl + " (Dead)";

        // Rot effect
        for (int i = 0; i < imgCHARAC.getWidth(); i++) {
          for (int j = 0; j < imgCHARAC.getHeight(); j++) {
            imgCHARAC.setRGB(i, j, imgCHARAC.getRGB(i, j) * (int) Math.pow(3, 3));
          }
        }

        // Make inventory open to looting
        INVENTORY.OPEN_INVEN = true;
      }
    }
  }
예제 #10
0
  public Color getColorAt(double x, double y) {
    int col = img.getRGB((int) x, (int) y);
    double r = col >> 16 & 0xff;
    double g = col >> 8 & 0xff;
    double b = col & 0xff;

    int col_r = img.getRGB((int) x + 1, (int) y);
    double rr = col_r >> 16 & 0xff;
    double gr = col_r >> 8 & 0xff;
    double br = col_r & 0xff;

    double fact = x - Math.floor(x);

    double rf = r + (rr - r) * fact;
    double gf = g + (gr - g) * fact;
    double bf = b + (br - b) * fact;

    col = img.getRGB((int) x, (int) y + 1);
    r = col >> 16 & 0xff;
    g = col >> 8 & 0xff;
    b = col & 0xff;

    col_r = img.getRGB((int) x + 1, (int) y + 1);
    rr = col_r >> 16 & 0xff;
    gr = col_r >> 8 & 0xff;
    br = col_r & 0xff;

    double rf2 = r + (rr - r) * fact;
    double gf2 = g + (gr - g) * fact;
    double bf2 = b + (br - b) * fact;

    fact = y - Math.floor(y);

    double rff = rf + (rf2 - rf) * fact;
    double gff = gf + (gf2 - gf) * fact;
    double bff = bf + (bf2 - bf) * fact;

    return new Color((int) rff, (int) gff, (int) bff);
  }
예제 #11
0
  /*
   * Method takes a parameter of a BufferedImage
   * and returns a 2d array
   */
  public static int[][] readIntoArray(BufferedImage x) {
    int width = x.getWidth();
    int height = x.getHeight();

    // initialize the 2d array to the size of the picture
    int[][] imagePixels = new int[width][height];

    for (int i = 0; i < width; i++) {
      for (int j = 0; j < height; j++) {
        imagePixels[i][j] = x.getRGB(i, j); // store RGB value in array
        //     printPixelARGB(x.getRGB(i,j));
      }
    }
    return imagePixels;
  }
예제 #12
0
파일: Picture.java 프로젝트: rafacb/MasLab
 public static void main(String[] args) throws Exception {
   Robot robot = new Robot(args[0]);
   BufferedImage oimg = robot.cam.capture(true);
   // BufferedImage img = maslab.camera.ImageUtil.convertImage(oimg, BufferedImage.TYPE_INT_RGB);
   BufferedImage img =
       new BufferedImage(oimg.getWidth(), oimg.getHeight(), BufferedImage.TYPE_INT_RGB);
   for (int y = 0; y < oimg.getHeight(); ++y) {
     for (int x = 0; x < oimg.getWidth(); ++x) {
       img.setRGB(x, y, oimg.getRGB(x, y));
     }
   }
   BufferedImage blurred = gaussianBlur(img);
   ImageIO.write(blurred, "bmp", new File("gaussian.bmp"));
   BufferedImage xe = sobelX(blurred);
   ImageIO.write(xe, "bmp", new File("sobelx.bmp"));
   BufferedImage ye = sobelY(blurred);
   ImageIO.write(ye, "bmp", new File("sobely.bmp"));
   BufferedImage edges = addMagnitudes(xe, ye);
   BufferedImage dst = edges;
   ImageIO.write(dst, "bmp", new File("edges.bmp"));
 }
예제 #13
0
파일: PageSmoother.java 프로젝트: pnf/bleh
  public void write() {

    int navg = 8;
    //		int nshift=3;
    bookend = 8;

    numPgs = pdffile.getNumPages();

    files = new File[numPgs];

    int[] pixelsi = null;
    long[] sum = null;
    long[][] hist = null;
    BufferedImage bimage = null;

    //		BufferedImage simage = null;
    //	    float data[] = { 0.0625f, 0.125f, 0.0625f, 0.125f, 0.25f, 0.125f,
    //	            0.0625f, 0.125f, 0.0625f };
    //	    Kernel kernel = new Kernel(3, 3, data);
    //	    ConvolveOp convolve = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);

    done(0);
    for (int i = 0; i < numPgs; i++) {
      if (i > MAXPAGE) break;
      PDFPage page = getPage(i);
      if (i == 0) {
        w = (int) page.getBBox().getWidth();
        h = (int) page.getBBox().getHeight();
        rect = new Rectangle(0, 0, w, h);
        // w /= 2; h /=2;
        bimage = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
        // simage = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
        pixelsi = new int[h * w];
        sum = new long[h * w];
        hist = new long[navg][h * w];
        for (int j = 0; j < h * w; j++) {
          sum[j] = 0;
        }
        page1.countDown();
      }

      // generate page image
      Image image = pdffile.getPage(i).getImage(w, h, rect, null, true, true);
      // force complete loading
      image = new ImageIcon(image).getImage();
      // Copy image to buffered image
      Graphics g = bimage.createGraphics();
      // Paint the image onto the buffered image
      g.drawImage(image, 0, 0, null);
      g.dispose();

      // extract pixels into array
      bimage.getRGB(0, 0, w, h, pixelsi, 0, w);
      // Accumulate rolling averages
      int im = i % navg;
      int ii = i - navg / 2; // middle of averaging range
      for (int j = 0; j < h * w; j++) {
        int p = pixelsi[j], q = 0;

        // Expand packed 8x3 pixel to 16x3
        long r = 0, r2 = 0;
        r |= (p & 0xff);
        r <<= 16;
        p >>= 8;
        r |= (p & 0xff);
        r <<= 16;
        p >>= 8;
        r |= (p & 0xff);
        r = ~r;
        sum[j] += r; // rolling sum
        if (i >= navg) { // we have enough to average
          sum[j] -= hist[im][j]; // roll off the old
          hist[im][j] = r;
          r2 = (3 * sum[j] / navg + r) / 4;
          r = ~r2;
        } else {
          hist[im][j] = r;
        }

        // Repack averaged pixel
        q |= (r & 0xff);
        q <<= 8;
        r >>= 16;
        q |= (r & 0xff);
        q <<= 8;
        r >>= 16;
        q |= (r & 0xff);

        //	Average over number of images frames with a non-background pixel in this location.
        //  Note that we sum in complement space, so background is zero.
        //				if(i>=navg)
        //				nfg[j] -= fghist[im][j];
        //			nfg[j] += (fghist[im][j] = (q==-1) ? 0 : 1);
        //
        //				// If all pixels in history were background, this is easy...
        //				if(nfg[j]==0)
        //					q = -1;
        //
        //				else {
        //
        //					if(i>=navg) sum[k]-=hist[im][k];
        //					hist[im][k] = ~(p&0xff);
        //					sum[k] += hist[im][k];
        //					if(i>=navg)
        //						q += ~(((sum[k]/nfg[j])*3 + hist[iim][k])>>2);
        //					else if(i>=navg/2)
        //						q += ~(sum[k]/nfg[j] + hist[i-navg/2][k])>>1;
        //					else
        //						q += ~(sum[k]/nfg[j]);
        //					k++; q<<=8; p>>=8;
        //
        //					if(i>=navg) sum[k]-=hist[im][k];
        //					hist[im][k] = ~(p&0xff);
        //					sum[k] += hist[im][k];
        //					if(i>=navg)
        //						q += ~(((sum[k]/nfg[j])*3 + hist[iim][k])>>2);
        //				else if(i>=navg/2)
        //				q += ~((sum[k]/nfg[j] + hist[i-navg/2][k])>>1);
        //			else
        //				q += ~(sum[k]/nfg[j]);
        //			k++; q<<=8; p>>=8;
        //
        //					if(i>=navg) sum[k]-=hist[im][k];
        //					hist[im][k] = ~(p&0xff);
        //					sum[k] += hist[im][k];
        //					if(i>=navg)
        //						q += ~(((sum[k]/nfg[j])*3 + hist[iim][k])>>2);
        //					else if(i>=navg/2)
        //						q += ~((sum[k]/nfg[j] + hist[i-navg/2][k])>>1);
        //					else
        //						q += ~(sum[k]/nfg[j]);
        //					k++;
        //				}

        pixelsi[j] = q;
      }

      bimage = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
      bimage.setRGB(0, 0, w, h, pixelsi, 0, w);

      // save it as a file
      if (i >= navg) {
        try {
          ImageIO.write(bimage, "png", imageFile(0, ii + 1));
        } catch (Exception e) {
          throw new RuntimeException(e.getMessage());
        }
      }

      done(ii + 1);
      // System.err.println("Page " + i + " " + (System.currentTimeMillis()-t0)/1000.);

      if (terminated) {
        System.err.println("Prematurely terminated");
        for (File f : files) f.delete();
        tmpdir.delete();
        break;
      }
    }
  }
예제 #14
0
  private IFD writeBModHufImage(
      ImageOutputStream out, BufferedImage image, TIFFImageWriteParam param) throws IOException {
    try {
      int width = image.getWidth();
      int height = image.getHeight();

      IFD ifd = new IFD(); // entries need to be in tag order !

      ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
      ifd.add(new DEFactory.ImageWidthDE(width)); // 256
      ifd.add(new DEFactory.ImageLengthDE(height)); // 257
      ifd.add(new DEFactory.CompressionDE(CCITTGROUP3MODHUFFMAN)); // 259
      ifd.add(new DEFactory.PhotometricInterpretationDE(WhiteIsZero)); // 262

      int maxrps, maxstripes; // max RowsPerStrip
      if ((1 << 13) <= width) {
        maxrps = 1;
        maxstripes = height; // one row per stripe
      } else {
        maxrps = (1 << 13) / width;
        maxstripes = (height + maxrps - 1) / maxrps;
      }

      DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
      ifd.add(offsets); // 273
      ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
      DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
      ifd.add(counts); // 279

      if (param == null) {
        ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
        ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
      } else {
        ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
        ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
      }
      ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296

      int index = 0;
      for (int y = 0; y < height; y += maxrps) {
        /*
        Assume bilevel image (black/white[=-1])

        Each strip: count run length
                    encode into modified hufman codes
                    swap bits
                    save in byte array
                    write to image file
        */

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        BitSwapOutputStream bsos = new BitSwapOutputStream(baos);
        ModHuffmanOutputStream mhos = new ModHuffmanOutputStream(bsos);

        RLEOutputStream rlos =
            new RLEOutputStream(mhos, 3); // rgb = 3 bytes per sample code word (not needed here)

        for (int i = 0; i < maxrps; i++) {
          if ((y + i) == height) {
            break;
          } // last strip might have less rows
          rlos.setStartCodeWord(-1); // white run first
          for (int x = 0; x < width; x++) {
            rlos.write(image.getRGB(x, y + i));
          }
          rlos.flush(); // write padding after ever image row
        }
        rlos.close();

        byte[] data = baos.toByteArray();
        counts.setCount(index, data.length); // update ifd strip counter array
        offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
        out.write(data); // write to image stream

        index++;
      }
      return ifd;
    } catch (Exception e) {
      e.printStackTrace();
      throw new IOException(getClass().getName() + ".writeBModHufImage:\n\t" + e.getMessage());
    }
  }
예제 #15
0
파일: CA.java 프로젝트: jkwhite/nausicaa
 public int[] getRow(int[] into, int y, int offset) {
   return _i.getRGB(0, y, into.length - 2 * offset, 1, into, offset, 0);
 }
예제 #16
0
파일: CA.java 프로젝트: jkwhite/nausicaa
 public int[] getRow(int[] into, int y) {
   return _i.getRGB(0, y, into.length, 1, into, 0, 0);
 }
예제 #17
0
파일: CA.java 프로젝트: jkwhite/nausicaa
 public int get(int x, int y) {
   x = boundx(x);
   y = boundy(y);
   return _i.getRGB(x, y);
 }
예제 #18
0
  private IFD writeCMYKImage(ImageOutputStream out, BufferedImage image, TIFFImageWriteParam param)
      throws IOException {
    try {
      int width = image.getWidth();
      int height = image.getHeight();

      IFD ifd = new IFD(); // entries need to be in tag order !

      ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
      ifd.add(new DEFactory.ImageWidthDE(width)); // 256
      ifd.add(new DEFactory.ImageLengthDE(height)); // 257

      DEFactory.BitsPerSampleDE bpss = new DEFactory.BitsPerSampleDE(4);
      bpss.setBitsPerSample(0, 8); // cyan
      bpss.setBitsPerSample(1, 8); // magneta
      bpss.setBitsPerSample(2, 8); // yellow
      bpss.setBitsPerSample(3, 8); // key (black)
      ifd.add(bpss); // 258

      ifd.add(new DEFactory.CompressionDE(NOCOMPRESSION)); // 259
      ifd.add(new DEFactory.PhotometricInterpretationDE(CMYK)); // 262

      int maxrps, maxstripes; // max RowsPerStrip
      if ((1 << 13) <= width) {
        maxrps = 1;
        maxstripes = height; // one row per strip
      } else {
        maxrps = (1 << 13) / width;
        maxstripes = (height + maxrps - 1) / maxrps;
      }

      DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
      ifd.add(offsets); // 273
      ifd.add(new DEFactory.SamplesPerPixelDE(4)); // 277
      ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
      DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
      ifd.add(counts); // 279

      if (param == null) {
        ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
        ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
      } else {
        ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
        ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
      }
      ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296

      int index = 0;
      for (int y = 0; y < height; y += maxrps) {
        /*
        Assume rgb image.

        Each strip: evaluate c m y k colour
                    save in byte array
                    write to image file
        */

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        for (int i = 0; i < maxrps; i++) {
          if ((y + i) == height) {
            break;
          } // last strip might have less rows
          for (int x = 0; x < width; x++) {
            int c = image.getRGB(x, y + i);

            int R = (c >> 16) & 0x00FF;
            int G = (c >> 8) & 0x00FF;
            int B = (c) & 0x00FF;

            if ((R == 255) && (G == 255) && (B == 255)) {
              baos.write(0);
              baos.write(0);
              baos.write(0);
              baos.write(0);
            } else {
              double C = 1.0 - R / 255.0;
              double M = 1.0 - G / 255.0;
              double Y = 1.0 - B / 255.0;

              double K = C;
              if (M < K) {
                K = M;
              }
              if (Y < K) {
                K = Y;
              }

              C = ((C - K) / (1.0 - K)) * 255.0;
              M = ((M - K) / (1.0 - K)) * 255.0;
              Y = ((Y - K) / (1.0 - K)) * 255.0;
              K *= 255.0;

              baos.write((int) C);
              baos.write((int) M);
              baos.write((int) Y);
              baos.write((int) K);
            }
          }
        }
        baos.close();

        byte[] data = baos.toByteArray();
        counts.setCount(index, data.length); // update ifd strip counter array
        offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
        out.write(data); // write to image stream

        index++;
      }
      return ifd;
    } catch (Exception e) {
      e.printStackTrace();
      throw new IOException(getClass().getName() + ".writeCMYKImage:\n\t" + e.getMessage());
    }
  }
예제 #19
0
  public erosion(String nombre) {

    imageName = nombre;

    // BufferedImage image2;
    String aux;

    // int ancho=image.getWidth();

    // BufferedImage image = ImageIO.read( new File( imageName ) );
    try {
      image = ImageIO.read(new File(imageName));
    } catch (IOException e) {
      System.out.println("image missing");
    }

    try {
      image2 = ImageIO.read(new File(imageName));
    } catch (IOException e) {
      System.out.println("image missing");
    }

    int k;
    int a;
    int b;
    int i;
    int j;

    int rojo;
    int verde;
    int azul;

    int promedio;
    try {
      int ancho, alto;
      alto = image.getHeight();
      ancho = image.getWidth();
      for (i = 0; i < ancho; i++) {
        for (j = 0; j < alto; j++) {
          k = image.getRGB(i, j);
          k = 0xFFFFFF + k;

          rojo = k / 0x10000;

          k = k % 0x10000;
          verde = k / 0x100;

          k = k % 0x100;
          azul = k;

          if (rojo < 0) rojo = 255 + rojo;
          if (verde < 0) verde = 255 + verde;
          if (azul < 0) azul = 255 + azul;

          promedio = azul + verde + rojo;
          promedio = promedio / 3;
          /*if(promedio<0)
          promedio=promedio+128;*/

          rojo = promedio;
          verde = promedio;
          azul = promedio;
          // printf("")

          if (promedio >= 128) promedio = 255;
          else promedio = 0;
          k = promedio + promedio * 0x100 + promedio * 0x10000;

          this.image.setRGB(i, j, k);
        }
      }
    } catch (Exception e) {
      System.out.printf("n");
    }
    //
    try {
      int ancho, alto;
      alto = image2.getHeight();
      ancho = image2.getWidth();
      for (i = 0; i < ancho; i++) {
        for (j = 0; j < alto; j++) {
          k = image2.getRGB(i, j);
          k = 0xFFFFFF + k;

          rojo = k / 0x10000;

          k = k % 0x10000;
          verde = k / 0x100;

          k = k % 0x100;
          azul = k;

          if (rojo < 0) rojo = 255 + rojo;
          if (verde < 0) verde = 255 + verde;
          if (azul < 0) azul = 255 + azul;

          promedio = azul + verde + rojo;
          promedio = promedio / 3;
          /*if(promedio<0)
          promedio=promedio+128;*/

          rojo = promedio;
          verde = promedio;
          azul = promedio;
          // printf("")

          k = promedio + promedio * 0x100 + promedio * 0x10000;

          this.image2.setRGB(i, j, k);
        }
      }
    } catch (Exception e) {
      System.out.printf("n");
    }

    //
    try {
      int ancho, alto;
      alto = image.getHeight();
      ancho = image.getWidth();
      for (i = 0; i < ancho; i++) {
        for (j = 0; j < alto; j++) {
          k = image.getRGB(i, j);
          k = 0xFFFFFF + k;

          rojo = k / 0x10000;

          k = k % 0x10000;
          verde = k / 0x100;

          k = k % 0x100;
          azul = k;

          if (rojo < 0) rojo = 255 + rojo;
          if (verde < 0) verde = 255 + verde;
          if (azul < 0) azul = 255 + azul;

          /*promedio=azul+verde+rojo;
          promedio=promedio/3;
          /*if(promedio<0)
           promedio=promedio+128;*/

          if (i < ancho - 2) {
            if (rojo >= 128) {
              k = image.getRGB(i + 1, j);
              k = 0xFFFFFF + k;

              rojo = k / 0x10000;

              k = k % 0x10000;
              verde = k / 0x100;

              k = k % 0x100;
              azul = k;

              if (rojo < 0) rojo = 255 + rojo;
              if (verde < 0) verde = 255 + verde;
              if (azul < 0) azul = 255 + azul;

              if (rojo >= 128) {
                k = image.getRGB(i + 2, j);
                k = 0xFFFFFF + k;

                rojo = k / 0x10000;

                k = k % 0x10000;
                verde = k / 0x100;

                k = k % 0x100;
                azul = k;

                if (rojo < 0) rojo = 255 + rojo;
                if (verde < 0) verde = 255 + verde;
                if (azul < 0) azul = 255 + azul;
                if (rojo < 128) {
                  k = 0;
                  this.image2.setRGB(i, j, k);
                  this.image2.setRGB(i + 1, j, k);
                  this.image2.setRGB(i + 2, j, k);
                }
              }

            } else {
              k = rojo + rojo * 0x100 + rojo * 0x10000;
              this.image2.setRGB(i, j, k);
            }
          }
        }
      }
    } catch (Exception e) {
      System.out.printf("n");
    }
    //

    /*else if(l==4)
    posterizacion();*/

    // Toolkit tool = Toolkit.getDefaultToolkit();
    // image = tool.getImage(imageName);

    // dialogo.setLocationRelativeTo(f);

  }