急急急！

Question

用JAVA编一个程序 实现PS的一个功能就行，像图像拉伸啊 锐化 浮雕 等等  急等！

Answer 1

http://download.csdn.net/source/1316638/

Answer 2

你说的效果可以做到，但是，没法做的和PS那样强大。。,java 这方面远不如C++高效，所以，即时你用java做出来了，不好用，也没有人用。我博客上有个将图片钝化的功能，你去找找看吧。

Answer 3

package 娱乐;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import java.io.*;// 图像的模糊与锐化public class 图像的模糊与锐化 extends JFrame implements ActionListener {
private JPanel jPanel = new JPanel(); //面板jPanel用于容纳模糊、锐化、还原图像按钮
private JButton buttonFile; //打开图像文件按钮
private JButton buttonBlur; //模糊图像按钮
private JButton buttonSharpen; //锐化图像按钮
private JButton buttonReset; //还原图像按钮
ImagePanel imagePanel = new ImagePanel(); //创建ImagePanel对象用于绘制图像public 图像的模糊与锐化() {
   super("图像的模糊与锐化演示"); //调用父类构造函数
   Container contentPane = getContentPane(); //得到容器
   buttonFile = new JButton("打开图像文件"); //实例化组件
   buttonFile.addActionListener(this); //增加事件监听  
   buttonBlur = new JButton("模糊图像");
   buttonBlur.addActionListener(this);  
   buttonSharpen = new JButton("锐化图像");
   buttonSharpen.addActionListener(this);  
   buttonReset = new JButton("还原图像");
   buttonReset.addActionListener(this);
  
   jPanel.add(buttonBlur); //增加组件到面板上
   jPanel.add(buttonSharpen);
   jPanel.add(buttonReset);
   contentPane.add(jPanel, BorderLayout.SOUTH); //增加组件到容器上
   contentPane.add(buttonFile, BorderLayout.NORTH);
   contentPane.add(imagePanel, BorderLayout.CENTER);
   //设置窗口
   this.setSize(280, 230); //设置窗口大小
   this.setVisible(true); //设置窗口可见
   this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //关闭窗口时退出程序
}public void actionPerformed(ActionEvent e) {
   JButton button = (JButton)e.getSource(); //获取事件源   
   //打开图像文件按钮buttonFile事件处理   
   if(button==this.buttonFile) {
    JFileChooser chooser = new JFileChooser(); //实例化文件选择器
    chooser.setFileSelectionMode(JFileChooser.FILES_ONLY); //设置文件打开模式为仅打开文件
    chooser.setCurrentDirectory(new File(".")); //设置文件选择器当前目录
    //设置图像文件过滤器
    chooser.setFileFilter(new javax.swing.filechooser.FileFilter() {
     public boolean accept(File file) { //可接受的文件类型
      String name = file.getName().toLowerCase();
      return name.endsWith(".gif")
       || name.endsWith(".jpg")
       || name.endsWith(".jpeg")
       || file.isDirectory(); 
     }
     public String getDescription() { //文件描述
      return "图像文件";
     }
    });
    int result = chooser.showOpenDialog(this); //显示文件选择对话框
    if (result == JFileChooser.APPROVE_OPTION) { //得到用户行为
     String fileName = chooser.getSelectedFile().getAbsolutePath(); //得到选择的文件名
     imagePanel.loadImage(fileName); //截入图像并显示
    }   
   }
   //模糊图像按钮buttonBlur事件处理
   else if(button==this.buttonBlur) {
    imagePanel.blur(); //模糊图像
    buttonReset.setEnabled(true); //设置还原图像按钮可用
   }
   //锐化图像按钮buttonSharpen事件处理  
   else if(button==this.buttonSharpen) {
    imagePanel.sharpen(); //锐化图像
    buttonReset.setEnabled(true); //设置还原图像按钮可用
   }
   //还原图像按钮buttonBlur事件处理
   else if(button==this.buttonReset) {
    imagePanel.reset(); //还原图像
    buttonReset.setEnabled(false); //设置还原图像按钮不可用
   }  
}public static void main(String[] args) {
   new 图像的模糊与锐化();
}public class ImagePanel extends JPanel {
   Image image; //被处理的图像
   BufferedImage bufImage; //用于显示的缓冲区图像
   BufferedImage originalBufImage; //原始缓冲区图像
   Graphics2D g2D; //图形环境   //载入图像
   public void loadImage(String fileName) {
    image = this.getToolkit().getImage(fileName); //获取图像
    MediaTracker mt = new MediaTracker(this); //实例化媒体加载器
    mt.addImage(image, 0); //增加待加载图像到媒体加载器
    try {
     mt.waitForAll(); //等待所有图像的加载完成
    } catch (Exception ex) { 
     ex.printStackTrace(); //输出出错信息
    }
    //创建原始缓冲区图像
    originalBufImage = new BufferedImage(image.getWidth(this),image.getHeight(this),BufferedImage.TYPE_INT_ARGB);
    g2D = originalBufImage.createGraphics(); //创建缓冲区图像的图形环境
    g2D.drawImage(image, 0, 0, this); //传输源图像数据到缓冲区图像中
    bufImage = originalBufImage;
    repaint(); //重绘组件
   }
     //过滤图像
     public void applyFilter(float[] data) {
    if (bufImage == null)
     return; //如果bufImage为空则直接返回
    Kernel kernel = new Kernel(3, 3, data); 
    ConvolveOp imageOp=new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP, null); //创建卷积变换操作对象
    BufferedImage filteredBufImage = new BufferedImage(image.getWidth(this),image.getHeight(this),BufferedImage.TYPE_INT_ARGB); //过滤后的缓冲区图像
    imageOp.filter(bufImage, filteredBufImage);//过滤图像，目标图像在filteredBufImage
    bufImage = filteredBufImage; //让用于显示的缓冲区图像指向过滤后的图像
    repaint(); //重绘组件   }
   //模糊图像
public void blur() {
    if (bufImage == null)
     return;
    float[] data = {
      0.0625f, 0.125f, 0.0625f,
      0.125f, 0.025f, 0.125f,
      0.0625f, 0.125f, 0.0625f 
    };
    applyFilter(data);
   }
   //锐化图像
   public void sharpen() {
    if (bufImage == null)
     return;
    float[] data = { 
           -1.0f, -1.0f, -1.0f,
           -1.0f, 9.0f, -1.0f,
           -1.0f, -1.0f, -1.0f 
    };
    applyFilter(data);
   }
   //恢复图像
   public void reset() {
    if (bufImage == null)
     return;
    bufImage = originalBufImage; //
    g2D.drawImage(image, 0, 0, this);
    repaint(); //调用paint()方法重绘组件
   }   public void paint(Graphics g) {
    super.paintComponent(g);
    //如果bufImage非空，则在组件上绘制它
    if (bufImage != null) {
     Graphics2D g2 = (Graphics2D) g;
     g2.drawImage(bufImage,(this.getWidth() - bufImage.getWidth()) / 2, (this.getHeight() - bufImage.getHeight()) / 2,this);
    }
   }
}
}

Answer 4

呵呵，会C++也写不出PS那样牛叉的软件啊，那不是一般人，写出来那种程序的，可以叫天才和大师了，世界上这种人也不多。更何况我正在初出茅庐的人。呵呵。希望有一天能到那种程度。努力吧。

Answer 5

搂主你直接说你想干嘛吧
是不是买不起photoshop，又不敢用盗版，所以想让大家给你写一个图像处理软件？

Answer 6

给你的同学写了个图片灰度处理的。放大缩小的类似啦，你到Googel上搜一下，肯定有很多例子。

Answer 7

给你找了个
package Magnifier;import java.awt.*;
import java.awt.event.*;
import javax.swing.*;public class Magnifier extends JFrame
{
    private Container container = getContentPane();    //我感觉这些变量名我不用说了.
    private int setCoordinateX;    private int setCoordinateY;    private int absoluteCoordinateX;    private int absoluteCoordinateY;    private int relativeCoordinateXWhenMousePressed;    private int relativeCoordinateYWhenMousePressed;    //标记鼠标是否按下。如果按下则为true，否则为false
    private boolean mousePressedNow;    // 放大镜尺寸
    private int magnifierSize = 300;    //放大镜内容面板
    private MagnifierPanel magnifierPanel = new MagnifierPanel(magnifierSize);    //这个窗体就是放大镜 你可以自己更改这个窗体..
    public Magnifier()
     {
       setUndecorated(true); // 这个就是窗口的边缘 false的话就失效果了
       setResizable(false); //以后这样的代码就不说了
       container.add(magnifierPanel);
       addMouseListener(new MouseFunctions());
       addMouseMotionListener(new MouseMotionFunctions());
       updateSize(magnifierSize);
       this.setVisible(true);
     }    public static void main(String arg[])
     {
    // JFrame 
     Magnifier magnifier = new Magnifier();
     magnifier.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     }    //从updateSize 方法名就可以直接看出这个方法干什么的啦。。我就不说啦..
    //都说好的方法名 根本不用加注释..哈哈..我正在向这方面发展咯
    
    public void updateSize(int magnifierSize)
     {
        magnifierPanel.setMagnifierSize(magnifierSize + 100);
        setSize(magnifierSize + 100, magnifierSize + 100);
        validate();// ET小姐教的 强行更新组件,,他不教我也会=.= 在这里BS他一下
     }    private class MouseFunctions extends MouseAdapter
     {
    public void mousePressed(MouseEvent e)
     {
        if (e.getClickCount() == 1)
         {// 如果鼠标左键点了一下，说明按住了窗体
         mousePressedNow = true;
         relativeCoordinateXWhenMousePressed = e.getX();
         relativeCoordinateYWhenMousePressed = e.getY();
         }
     }    public void mouseReleased(MouseEvent e)
     {
         mousePressedNow = false;
     }
    }    private class MouseMotionFunctions extends MouseMotionAdapter
     {
     public void mouseDragged(MouseEvent e)
     {
      if (mousePressedNow == true)
      {// 如果此时鼠标按下了，说明在拖拽窗体
       absoluteCoordinateX = Magnifier.this
          .getLocationOnScreen().x
           + e.getX();
       absoluteCoordinateY = Magnifier.this
        .getLocationOnScreen().y
        + e.getY();
       setCoordinateX = absoluteCoordinateX
        - relativeCoordinateXWhenMousePressed;
       setCoordinateY = absoluteCoordinateY
            - relativeCoordinateYWhenMousePressed;
       magnifierPanel.setMagnifierLocation(setCoordinateX,
            setCoordinateY);
       setLocation(setCoordinateX, setCoordinateY);
      }
     }
     }
}class MagnifierPanel extends JPanel
{
    private Image screenImage;    private int magnifierSize;    private int locationX;    private int locationY;    private Robot robot;     public MagnifierPanel(int magnifierSize)
     {
       try
          {
            robot = new Robot();
          }
       catch (AWTException e){
       }
     // 截屏幕  参数就自己看API吧
       screenImage = robot.createScreenCapture(new Rectangle(0, 0, Toolkit
         .getDefaultToolkit().getScreenSize().width, Toolkit
         .getDefaultToolkit().getScreenSize().height));
      
      this.magnifierSize = magnifierSize;
     }    public void setMagnifierLocation(int locationX, int locationY)
     {
    //X坐标
     this.locationX = locationX;
    //Y坐标
     this.locationY = locationY;
     repaint();        // 注意重画控件
     }    public void setMagnifierSize(int magnifierSize)
     {
     this.magnifierSize = magnifierSize;
     }    public void paintComponent(Graphics g)
     {
     super.paintComponent((Graphics2D) g);
    // 关键处理代码
     g.drawImage(
       screenImage,                 // 要画的图片
       0,                    // 目标矩形的第一个角的x坐标     
       0,                    // 目标矩形的第一个角的y坐标
       magnifierSize,                 // 目标矩形的第二个角的x坐标
       magnifierSize,                 // 目标矩形的第二个角的y坐标
       locationX + (magnifierSize / 4),     // 源矩形的第一个角的x坐标
       locationY + (magnifierSize / 4),    // 源矩形的第一个角的y坐标
       locationX + (magnifierSize / 4 * 3),     // 源矩形的第二个角的x坐标
       locationY + (magnifierSize / 4 * 3),     // 源矩形的第二个角的y坐标
       this
     );
   }
}

Answer 8

下面是旋转的
package Demo628;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;public class ImageRote
{
    public static void main(String[] args)
    {
        JFrame frame = new TransformFrame();
        frame.setVisible(true);
    }
}class TransformFrame extends JFrame implements ActionListener
{
    //添加几个按钮方便操作。
    JButton rote = new JButton("旋转") ;
    JButton flipX= new JButton("水平翻转");
    JButton flipY= new JButton("垂直翻转");
    JButton zoomIn = new JButton("放大") ;
    JButton zoomOut = new JButton("缩小") ;
    public TransformFrame()
    {
        setTitle("TransformTest");
        setSize(400, 400);
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
        Container contentPane = getContentPane();
        canvas = new TransPanel();
        contentPane.add(canvas, "Center");
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(rote);
        rote.addActionListener(this);
        buttonPanel.add(flipX);
        flipX.addActionListener(this);
        buttonPanel.add(flipY);
        flipY.addActionListener(this);
        
        buttonPanel.add(zoomIn) ;
        zoomIn.addActionListener(this) ;
        buttonPanel.add(zoomOut) ;
        zoomOut.addActionListener(this) ;
        contentPane.add(buttonPanel, "North");
    }    public void actionPerformed(ActionEvent event)
    {
        Object source = event.getSource();
        //对于source == ???这种方法，在特殊的情况下出现错误，所以，需要酌情使用event.getSource().equals()方法来替代==
        if (source == rote)
        {
            canvas.setRotate();
        } else
        if (source == flipX)
        {
            canvas.flipX();
        } else
        if (source == flipY)
        {
            canvas.flipY();
        } else
        if (source == zoomIn)
        {
            canvas.zoomIn();
        } else
        if (source == zoomOut)
        {
            canvas.zoomOut();
        }
    }
    private TransPanel canvas;
}class TransPanel extends JPanel
{
    //水平翻转比例的标志。-1表示需要进行水平翻转
    int m_nFlipXScale = 1 ;
    //垂直翻转比例的标志。-1表示需要进行垂直翻转
    int m_nFlipYScale = 1 ;
    //旋转的角度。因为工程需要，代码中直接写成了90，可以根据具体需要动态修改，以符合实际情况
    int roteAngle = 0 ;    
    //缩放比例。默认的比例0表示没有翻转，具体的翻转大小通过一个方法:getZoomSize()获取
    int zoomLevel = 0 ;
    public TransPanel()
    {
        //首先载入一张图片。
        img = new ImageIcon("D000.GIF").getImage();
    }
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        g.drawImage(img,0,0,this) ;
        
        drawTransImage(g,img.getWidth(this),img.getHeight(this),zoomLevel) ;
        
    }
    
    public void drawTransImage(Graphics g,int drawx,int drawy,int zoom)
    {
        int x = 0 ;
        int y = 0 ;
        int w = img.getWidth(this) ;
        int h = img.getHeight(this) ;
        int zoomw = getZoomSize(w,zoom) ;
        int zoomh = getZoomSize(h,zoom) ;
        int xPos = 0 ;
        int yPos = 0 ;
        if (m_nFlipXScale == -1)
              xPos = -zoomw ;
        if (m_nFlipYScale == -1)
              yPos = -zoomh ;
        Graphics2D g2 = (Graphics2D)g ;
        //转换坐标原点。这步不要也成，但是将当前位置转换为坐标原点后，可以节省好多计算步骤，非常好用。
         //不过记得用完了以后，一定要把原点转换回来，要不然其他地方就乱了
        g2.translate(drawx,drawy);
        if (roteAngle != 0)
              g2.rotate(Math.toRadians(m_nFlipXScale * m_nFlipYScale * roteAngle),zoomw >> 1,zoomh >> 1);
              //上面的m_nFlipXScale * m_nFlipYScale需要特殊说明一下：因为实际使用中，可能遇到各种组合的情况，比如
                //先flipX或者flipY以后然后再旋转，这时候，图片的旋转方向就会出现错误，加上这段代码可以保证无论使用哪种组合
                //操作方式，都保证在旋转图片的时候是按照顺时针的方向进行旋转。
        if (m_nFlipXScale == -1)
              g2.scale(-1,1);//第一个值表示水平，-1表示等宽水平翻转，Math.abs(m_nFlipXScale)的值越大，出来的图片就越宽
        if (m_nFlipYScale == -1)
              g2.scale(1,-1);//第二个值表示垂直，-1表示等高垂直翻转，Math.abs(m_nFlipYScale)的值越大，出来的图片就越高
        //显示图片
        g2.drawImage(img,xPos,yPos,xPos + zoomw,yPos + zoomh,x,y,w,h,null) ;
        g2.translate(-drawx,-drawy);        
    }
    public void setRotate()
    {
        roteAngle += 90 ;
        roteAngle %= 360 ;
        repaint();
    }
    public void flipX()
    {
        m_nFlipXScale = -m_nFlipXScale ;
        repaint();
    }
    
    public void flipY()
    {
        m_nFlipYScale = -m_nFlipYScale ;
        repaint();
    }    
    
    public void zoomIn()
    {
        zoomLevel++ ;
        repaint();
    }
    
    public void zoomOut()
    {
        zoomLevel-- ;
        repaint();
    }
    
    public static final int getZoomSize(int sourceSize,int zoomLevel)
    {
        if (zoomLevel == 0)
              return sourceSize ;
        else
        if (zoomLevel < 0)
            return sourceSize / (Math.abs(zoomLevel) + 1) ;
        else
            return sourceSize * (zoomLevel + 1) ;
      }    
    private Image img;
}