【转载】java 实现 图片不规则(多边形)裁剪,绘图,添加水印

最新推荐文章于 2023-05-30 16:52:16 发布
最新推荐文章于 2023-05-30 16:52:16 发布
阅读量1k 收藏 8
点赞数 1
分类专栏： JAVA
原文链接：https://www.cnblogs.com/Lixiaogang/p/13157343.html
版权

https://www.cnblogs.com/Lixiaogang/p/13157343.html

应业务需求,需要对图片进行二次处理,裁剪出不规则图形保存,原图画不规则图形.

 



import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.TexturePaint;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;  
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.imageio.ImageIO;  
import javax.imageio.ImageReadParam;  
import javax.imageio.ImageReader;  
import javax.imageio.stream.ImageInputStream;
import javax.swing.ImageIcon;

public class ImageUtils {  
    /**
     * 矩形裁剪jpg
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x 原点x坐标
     * @param y 原点y坐标
     * @param width 宽
     * @param height 高
     * @throws IOException
     */
    public static void cut_JPG(String inputFilePath, String outFilePath, int x,
            int y, int width, int height) throws IOException {
        ImageInputStream imageStream = null;
        try {
            FileInputStream input = new FileInputStream(inputFilePath);
            Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpg");
            ImageReader reader = readers.next();
            imageStream = ImageIO.createImageInputStream(input);
            reader.setInput(imageStream, true);
            ImageReadParam param = reader.getDefaultReadParam();
            
            Rectangle rect = new Rectangle(x, y, width, height);
            param.setSourceRegion(rect);
            BufferedImage bi = reader.read(0, param);
            
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(bi, "jpg", out);
            
            input.close();
            out.close();
        } finally {
            imageStream.close();
        }
    }
      
    /**
     * 矩形裁剪png
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x 原点x坐标
     * @param y 原点y坐标
     * @param width 宽
     * @param height 高
     * @throws IOException
     */
    public static void cut_PNG(String inputFilePath, String outFilePath, int x,
            int y, int width, int height) throws IOException {
        ImageInputStream imageStream = null;
        try {
            FileInputStream input = new FileInputStream(inputFilePath);
            Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("png");
            ImageReader reader = readers.next();
            imageStream = ImageIO.createImageInputStream(input);
            reader.setInput(imageStream, true);
            ImageReadParam param = reader.getDefaultReadParam();
            
            Rectangle rect = new Rectangle(x, y, width, height);
            param.setSourceRegion(rect);
            BufferedImage bi = reader.read(0, param);
            
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(bi, "png", out);
            input.close();
            out.close();
        } finally {
            imageStream.close();
        }
    }
     /**
      * 矩形裁剪
      * @param inputFilePath 图片输入路径
      * @param outFilePath 图片输出路径
      * @param type 图片类型
      * @param x 原点x坐标
      * @param y 原点y坐标
      * @param width 宽
      * @param height 高
      * @throws IOException
      */
    public static void cut_Image(String inputFilePath, String outFilePath, String type,int x,
            int y, int width, int height) throws IOException {
        ImageInputStream imageStream = null;
        try {
            FileInputStream input = new FileInputStream(inputFilePath);
            String imageType=(null==type||"".equals(type))?"jpg":type;
            Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageType);
            ImageReader reader = readers.next();
            imageStream = ImageIO.createImageInputStream(input);
            reader.setInput(imageStream, true);
            ImageReadParam param = reader.getDefaultReadParam();
            Rectangle rect = new Rectangle(x, y, width, height);
            param.setSourceRegion(rect);
            BufferedImage bi = reader.read(0, param);
            
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(bi, imageType, out);
            input.close();
            out.close();
        } finally {
            imageStream.close();
        }
    }
    /**
     * 图片矩形裁切
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x 原点x坐标
     * @param y 原点y坐标
     * @param width 宽
     * @param height 高
     */
    public static void cut_Image2(String inputFilePath,String outFilePath,int x, int y, int width, int height) {
        try {
            File f = new File(inputFilePath);
            File t = new File(outFilePath);
            if (t.exists()) {
                t.delete();
            }
            //图片输入流
            ImageInputStream input = ImageIO.createImageInputStream(f);
            //图片读取器
            Iterator<ImageReader> it = ImageIO.getImageReaders(input);
            if (it.hasNext()) {
                ImageReader r = it.next();
                //设置输入流
                r.setInput(input, true);
                //读取参数
                ImageReadParam param = r.getDefaultReadParam();
                //创建要截取的矩形范围
                Rectangle rect = new Rectangle(x, y, width, height);
                //设置截取范围参数
                param.setSourceRegion(rect);
                //读取截图数据
                BufferedImage bi = r.read(0, param);
                // 保存图片
                ImageIO.write(bi, "jpg", t);
            }
            input.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
    /**
     * 裁剪(多边形)
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x[] x轴坐标点数组
     * @param y[] y轴坐标点数组
     * @param n 坐标点数量
     * @throws IOException
     */
    public static void cutPolygon_Image( String inputFilePath,String outFilePath,int x[],  
            int y[],int n) throws IOException {
        try {
            BufferedImage image = ImageIO.read(new File(inputFilePath));
            GeneralPath clip = new GeneralPath(GeneralPath.WIND_EVEN_ODD, n);
            //int x[]={860,650,300,1700};
            //int y[]={20,20,1000,1000};
            clip.moveTo(x[0], y[0]);
            for (int i = 1; i < x.length; i++) {
                clip.lineTo(x[i], y[i]);
            }
            clip.closePath();
            
            Rectangle bounds = clip.getBounds();
            //BufferedImage img = new BufferedImage(bounds.width, bounds.height, BufferedImage.TYPE_INT_BGR);
            BufferedImage img = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_BGR);
            Graphics2D g2d = img.createGraphics();
            //clip.transform(AffineTransform.getTranslateInstance(0, 0));
            g2d.setClip(clip);
            //g2d.translate(0, 0);
            g2d.drawImage(image, 0, 0, null);
            g2d.dispose();

            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(img, "jpg", out);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 绘图(图片上添加文字)
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param list 文字内容及坐标
     * @throws IOException
     */
    public static void drawingText_Image( String inputFilePath,String outFilePath,List<Map<String,Object>> list) throws IOException {
        try {
            /*List<Map<String, Object>> listMap = new ArrayList<Map<String,Object>>();
            Map<String, Object> map = null;
            
            map = new HashMap<String , Object>();
            map.put("text","文字内容");
            map.put("x", 100);
            map.put("y", 100);
            listMap.add(map);*/
            
            BufferedImage image = ImageIO.read(new File(inputFilePath));
            Graphics2D g =(Graphics2D) image.getGraphics();
            g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            g.setColor(Color.YELLOW); //字体颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 32)); //字体样式
            for (Map<String, Object> map : list) {
                g.drawString((String) map.get("text"), (int)map.get("x"),(int)map.get("y"));
            }
            g.dispose();
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(image, "jpg", out);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 绘图(画矩形框)
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x 原点x坐标
     * @param y 原点y坐标
     * @param width 宽
     * @param height 高
     */
    public static void drawingRectangular_Image( String inputFilePath,String outFilePath, int x,  
            int y, int width, int height) throws IOException {
        try {
            
            BufferedImage image = ImageIO.read(new File(inputFilePath));
            Graphics2D g =(Graphics2D) image.getGraphics();
            g.setColor(Color.YELLOW);//画笔颜色
            g.setStroke(new BasicStroke(3.0f));//设置线宽
            g.drawRect(x, y, width, height);//矩形框(原点x坐标，原点y坐标，矩形的长，矩形的宽)
            //g.fillRect(x, y, width, height);//画矩形着色块
            //g.draw3DRect(x, y, width, height,true);//画三维矩形
            
            g.dispose();
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(image, "jpg", out);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    } 
      
    /**
     * 绘图(画多边形框)
     * @param inputFilePath 图片输入路径
     * @param outFilePath 图片输出路径
     * @param x[] x轴坐标点数组
     * @param y[] y轴坐标点数组
     * @param n 坐标点数量
     * @throws IOException
     */
    public static void drawingPolygon_Image( String inputFilePath,String outFilePath, int x[],  
            int y[],int n) throws IOException {
        try {
            
            BufferedImage image = ImageIO.read(new File(inputFilePath));
            Graphics2D g =(Graphics2D) image.getGraphics();
            g.setColor(Color.YELLOW);//画笔颜色
            g.setStroke(new BasicStroke(3.0f));//设置线宽
            
            //int x[]={860,650,300,1700};
            //int y[]={20,20,1000,1000};
            g.drawPolygon(x,y,n);// 画多边形
            g.dispose();
            FileOutputStream out = new FileOutputStream(outFilePath);//输出图片的地址
            ImageIO.write(image, "jpg", out);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    } 
    
    /**  
     * 添加图片水印 
     * @param iconPath 水印图片路径
     * @param inputFilePath 源图片路径  
     * @param outFilePath 图片输出路径  
     * @param degree 水印图片旋转角度  
     */  
    public static void imageWatermarking_Image(String iconPath, String inputFilePath,String outFilePath, Integer degree) {   
        try {   
            Image srcImg = ImageIO.read(new File(inputFilePath));
            
            BufferedImage buffImg = new BufferedImage(srcImg.getWidth(null),
                    srcImg.getHeight(null), BufferedImage.TYPE_INT_RGB);

            // 得到画笔对象   
            // Graphics g= buffImg.getGraphics();   
            Graphics2D g = buffImg.createGraphics();   

            // 设置对线段的锯齿状边缘处理   
            g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                    RenderingHints.VALUE_INTERPOLATION_BILINEAR);   

            g.drawImage(srcImg.getScaledInstance(srcImg.getWidth(null), srcImg   
                    .getHeight(null), Image.SCALE_SMOOTH), 0, 0, null);   

            if (degree != null) {
                // 设置水印旋转 
                g.rotate(Math.toRadians(degree),
                        (double) buffImg.getWidth() / 2,
                        (double) buffImg.getHeight() / 2);
            }

            // 水印图象的路径 水印一般为gif或者png的，这样可设置透明度   
            ImageIcon imgIcon = new ImageIcon(iconPath);

            // 得到Image对象。
            Image img = imgIcon.getImage();
  
            float alpha = 0.4f; // 透明度 
            g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,alpha));

            // 表示水印图片的位置 
            g.drawImage(img, 15, 30, null);

            g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));

            g.dispose();

            OutputStream out = new FileOutputStream(outFilePath);

            // 生成图片
            ImageIO.write(buffImg, "jpg", out);

            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
     /**
      * 添加文字水印
      * @param inputFilePath 源图片路径
      * @param outFilePath 保存的图片路径
      * @param waterMarkContent 水印内容
      * @param degree 旋转角度
      * @param xmove 水印间距
      * @param ymove 水印间距
      */
     public static void textWatermarking_Image(String inputFilePath,String outFilePath,
             String waterMarkContent,Integer degree , int xmove,int ymove) {
         try {
             // 读取原图片信息
             File srcImgFile = new File(inputFilePath);// 得到文件
             Image srcImg = ImageIO.read(srcImgFile);// 文件转化为图片
             int srcImgWidth = srcImg.getWidth(null);// 获取图片的宽
             int srcImgHeight = srcImg.getHeight(null);// 获取图片的高
             // 加水印
             BufferedImage bufImg = new BufferedImage(srcImgWidth, srcImgHeight,BufferedImage.TYPE_INT_RGB);
             Graphics2D g = bufImg.createGraphics();
             // 设置对线段的锯齿状边缘处理
             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);
             // g.drawImage(srcImg, 0, 0, srcImgWidth, srcImgHeight, null);
             g.drawImage(
                     srcImg.getScaledInstance(srcImg.getWidth(null),
                             srcImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0,null);
             // 设置水印旋转
             if (null != degree) {
                 g.rotate(Math.toRadians(degree),
                         (double) bufImg.getWidth() / 2,
                         (double) bufImg.getHeight() / 2);
             }
             Font font = new Font("宋体", Font.PLAIN, 20);
             
             g.setColor(new Color(107, 109, 106)); //水印颜色
             g.setFont(font); // 设置字体
//             g.setFont(new Font("宋体", Font.PLAIN, srcImg.getWidth(null)/300*15));
             // 设置水印文字透明度
//             g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,0.5f));
  
             // 设置水印的坐标
             int x = -srcImgWidth / 2;
             int y = -srcImgHeight / 2;
             int markWidth = font.getSize() * getTextLength(waterMarkContent);// 字体长度
             int markHeight = font.getSize();// 字体高度
//             BigDecimal number= new BigDecimal(srcImg.getWidth(null));
//             BigDecimal olDnumber= new BigDecimal(800);
             
//             Integer MOVE = number.divide(olDnumber).intValue()*150;
             // 循环添加水印
             while (x < srcImgWidth * 1.5) {
                 y = -srcImgHeight / 2;
                 while (y < srcImgHeight * 1.5) {
                     g.drawString(waterMarkContent, x, y);
                     y += markHeight + ymove;
                 }
                 x += markWidth + xmove;
             }
             g.dispose();
  
             // 输出图片
             FileOutputStream outImgStream = new FileOutputStream(outFilePath);
             ImageIO.write(bufImg, "jpg", outImgStream);
             outImgStream.flush();
             outImgStream.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
    
     /**
      * 获取文本长度。汉字为1:1，英文和数字为2:1
      */
     private static int getTextLength(String text) {
         int length = text.length();
         for (int i = 0; i < text.length(); i++) {
             String s = String.valueOf(text.charAt(i));
             if (s.getBytes().length > 1) {
                 length++;
             }
         }
         length = length % 2 == 0 ? length / 2 : length / 2 + 1;
         return length;
     }
    
    public static void main(String[] args) {
        String inputFilePath = "E:/picOcr/original/20200615000000001.jpg";
        String outFilePath = "E:/picOcr/interception/20200615000000001.jpg";
        
        String iconPath = "E:/picOcr/2020592210413248.jpg";
        
        try {
            //裁剪矩形
            //ImageUtils.cut_JPG(inputFilePath, outFilePath, 400,300,900,750);
            
            //ImageUtils.cut_Image(inputFilePath, outFilePath,"jpg", 400,300,900,750);
            
            //ImageUtils.cut_Image2(inputFilePath, outFilePath, 400,300,900,750);
            
            //裁剪多边形
            /*int x[]={860,650,300,1700};
            int y[]={20,20,1000,1000};
            ImageUtils.cutPolygon_Image(inputFilePath, outFilePath,x,y,4);*/
            
            //绘图多边形
            /*int x[]={860,650,400,300,1700};
            int y[]={20,20,500,1000,1000};
            ImageUtils.drawingPolygon_Image(inputFilePath, outFilePath, x, y, 5);*/
            
            //绘图矩形
            //ImageUtils.drawingRectangular_Image(inputFilePath, outFilePath, 400, 300, 900,750);
            
            
            //绘图 添加文字
            /*List<Map<String, Object>> listMap = new ArrayList<Map<String,Object>>();
            Map<String, Object> map = null;
            
            map = new HashMap<String , Object>();
            map.put("text","文字内容");
            map.put("x", 100);
            map.put("y", 100);
            listMap.add(map);
            
            map = new HashMap<String , Object>();
            map.put("text","图片注释");
            map.put("x", 100);
            map.put("y", 140);
            listMap.add(map);
            
            ImageUtils.drawingText_Image(inputFilePath, outFilePath, listMap);*/
            
            //添加图片水印
            //ImageUtils.imageWatermarking_Image(iconPath, inputFilePath, outFilePath, -45);
            
            //添加文字水印
            ImageUtils.textWatermarking_Image(inputFilePath, outFilePath, "版权所有", -45, 80, 80);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        
    }
    
    
}

 


 

mu_ping
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
怎么用java画出多个多边形_java - 如何使用javacv编辑此方法来绘制多边形？ - 堆栈内存溢出...
weixin_39621178的博客
03-02 203
我在stackoverflow中经历了许多问题和问题，我找到了以下用于绘制矩形的方法。public static void drawSquares( IplImage image, final CvSeq squares ){if(!squares.isNull()){CvSeq p = new CvSeq(squares.total());cvCvtSeqToArray(squares, p, ...
JavaCV 绘制多边形
qq_45393130的博客
08-18 807
提示：个人学习探索过程，不一定完全正确，请理性看待。 文章目录前言一、JavaCV包导入二、绘制多边形总结 前言 提示：JavaCV 提供了在计算机视觉领域的封装库，包括：OpenCV、ARToolKitPlus、libdc1394 2.x 、PGR FlyCapture和FFmpeg。此外，该工具可以很容易地使用Java平台的功能。 提示：以下是本篇文章正文内容，下面案例可供参考 一、JavaCV包导入 在Maven仓库中搜索JavaCV ,选择 JavaCV Platform 根据自己的需求选择版
c#语言实现三维球体上不规则多边形的面积解法.zip
01-30
c#语言实现三维球体上不规则多边形的面积解法.zip
如何在Java中进行图片剪裁
verynicel的专栏
12-04 332
在这篇文章中我们将学习如何用 Java 对图像进行剪裁并将剪裁出来的部分单独保存到文件中。接下来我们开始编码部分。 AD： 这是一篇入门级文章，高手请略过。 在这篇文章中我们将学习如何用 Java 对图像进行剪裁并将剪裁出来的部分单独保存到文件中。 我们将通过以下步骤来学习： 输入图像，指定要处理的图像路径 允许用户拖放要剪裁的部分 选
JAVA实现不规则图形界面
qq_36466762的博客
10-26 1956
JAVA做图形界面是短处，所以也不建议大家用JAVA做界面开发，我也仅仅简单介绍不规则界面的实现方法。
Java工具类 - 根据左上角坐标和右下角坐标裁剪图片
热门推荐
窗边冷月光
04-19 1万+
package cut; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; import javax.imageio.ImageIO; import java.awt.image.BufferedImage; import java.io.*; import java.util.Arrays; /** * 根据左上角...
java图像处理之图像裁剪
jameschen9051的博客
08-18 3987
图像裁剪即截取原始图像某一部分生成一幅新的图像，某些app也会要求用户将上传图像进行一定程度裁剪来作为头像。图像裁剪实现起来比较简单，下面介绍两种裁剪方式，矩形裁剪和圆形裁剪。 矩形裁剪，定义图像上某个坐标(x,y)作为裁剪起始位置，xLength和yLength作为水平方向和垂直方向裁剪长度。由于裁剪范围可能超限，即裁剪起始位置到裁剪长度超过原始图像图像范围，需...
java 不规则截取图片_java 根据坐标截取图片实例代码
weixin_29009881的博客
01-12 402
java 根据坐标截取图片实例代码：代码中有不是注释，很好看懂！package com.json.test;import java.awt.Rectangle;import java.awt.image.BufferedImage;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import...
GDAL影像数据(tiff)裁剪并进行投影坐标转换(Java实现)
欢迎光临Andy511823558的空间
05-30 1463
对tiff文件进行按经纬度范围裁剪，在内存中裁剪，而gdal.Warp只能根据输入的shp文件进行裁剪。
Java图像切分（规则的不规则的都行）
dugeyang0520的博客
07-28 702
在处理图像时遇到了一些问题，需要从一个大图中切分出小的图形，当然，提前需要目标检测或者提前知道要切在哪里 今天使用下面这个图片 先来说说规则图形的切法（一般就是切个矩形） public static void main(String[] args) throws IOException { String totalPath = "C:\\Users\\dugey\\Desktop\\pictrue\\picturepython.jpg"; File fil..
蓝色不规则立体多边形PPT背景图片
07-16
这是一张蓝色不规则立体多边形PPT背景图片； 关键词：蓝色幻灯片背景图片，立体多边形PowerPoint背景图片，.jpg格式；
不规则多边形面积周长计算.rar
05-18
C#不规则多边形面积周长计算
Weiler-Atherton算法 实现多边形裁剪
01-16
用矩形来裁剪任意多边形，暂时没有考虑交点是多边形或矩形顶点的情况。
蓝色不规则立体多边形背景图片PPT模板
03-20
这是一张蓝色不规则立体多边形PPT背景图片； 关键词：蓝色幻灯片背景图片，立体多边形PowerPoint背景图片，.jpg格式；
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码
04-25
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码 微分方程 含有导数或微分的方程称为微分方程，未知函数为一元函数的微分方程称为常微分方程。 微分方程的阶数 微分方程中导数或微分的最高阶数称为微分方程的阶数。 微分方程的解 使得微分方程成立的函数称为微分方程的解。 微分方程的特解 微分方程的不含任意常数的解称为微分方程的特解。 微分方程的通解 所含相互独立的任意常数的个数与微分方程的阶数相等的微分方程的解称为微分方程的通解。
桌面聊天室
04-25
该毕业设计采用了c/s架构，通过javase中的知识编写完成，系统功能包括：用户注册，用户登录，聊天功能。 对于刚学完java基础的同学来说可以通过该毕业设计加深对所学知识的理解。该系统使用socket进行数据的发送，用户注册登录之后，可以进行多人聊天，功能类似qq群聊。
【前端素材】大数据-交通大屏.zip
最新发布
04-25
大数据技术指的是用于处理和分析大规模数据集的技术和工具。以下是一些常见的大数据技术和工具： Hadoop：Apache Hadoop是一个用于分布式存储和处理大规模数据的开源框架。它包括Hadoop Distributed File System（HDFS）用于数据存储和MapReduce用于数据处理。 Spark：Apache Spark是一个快速、通用的集群计算系统，提供了比MapReduce更快的数据处理能力。它支持内存计算和更多复杂的数据处理流程。 NoSQL数据库：NoSQL数据库（如MongoDB、Cassandra等）则更适用于处理这类数据。 数据仓库：数据仓库是一个用于集成和分析大规模数据的存储系统，一些知名的数据仓库包括Snowflake、Amazon Redshift等。 数据湖：数据湖是一个存储结构化和非结构化数据的存储池，用于支持数据分析和机器学习应用。 机器学习：大数据技术也广泛应用于机器学习领域，支持大规模数据的模型训练和预测分析。 流式处理：针对实时数据处理需求，流式处理技术（如Apache Kafka、Apache Flink）可以实时。
inspect：windows系统下的控件识别工具
04-25
windows系统下的控件识别工具，可用于桌面应用的UI自动化测试
038ssm-jsp-mysql高校毕业生就业满意度调查统计系统.zip（可运行源码+数据库文件+文档）
04-25
高校毕业生就业满意度调查统计系统是以实际运用为开发背景，运用软件工程开发方法，采用jsp技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本高校毕业生就业满意度调查统计系统采用的数据库是Mysql，使用JSP技术开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。 关键词：高校毕业生就业满意度调查统计系统，JSP技术，Mysql数据库
用opengl程序实现weiler-atherton多边形裁剪算法
10-13
weiler-atherton多边形裁剪算法是一种常用的多边形与裁剪窗口之间的运算方法。下面是一个基于OpenGL的实现步骤： 1. 首先，你需要创建一个OpenGL的窗口，并设置好绘图环境。 2. 然后，你需要定义多边形和裁剪窗口...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值