1.该图像识别方法,
(1)获取整个图片的所有rgb数量存储在list中
(2)统计每个list中R,g,b,各个在每个list中存储值对应的数量,存储到map中,存储中key的大小是乱序的,需要重新排序,(按照key的大小由小到大)
(3)把map中的特征图进行处理,对获取的map进行微分图像处理,形成更有特征的图像数据,提取特征数据存储数据库,形成了该图像的特征数据.
(4)识别图像与数据库中的数据进行比对,找到对应的数据.
2,看看类
MainDemo
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.io.*;
import java.awt.image.*;
import javax.imageio.ImageIO;
import java.text.SimpleDateFormat;
import org.jfree.chart.ChartPanel;
public class MainDemo implements ActionListener {
JFrame frame=null;
JLabel label=new JLabel();//用于显示图片
JLabel dealLabel=new JLabel();//用于显示处理后的图片
BufferedImage bi=null;//用于存储临时打开的图片流
//定义用于存储图片的数据,先获取r,g,b各个的数据,
//然后再每个数据内查找指定r,g,b,出现的次数(0-255)出现的次数
ArrayList<Integer> rList=new ArrayList<Integer>();
ArrayList<Integer> gList=new ArrayList<Integer>();
ArrayList<Integer> bList=new ArrayList<Integer>();
//用于存储各个数据对应的值
LinkedHashMap<Integer,Integer> rMap=new LinkedHashMap<Integer,Integer>();
LinkedHashMap<Integer,Integer> gMap=new LinkedHashMap<Integer,Integer>();
LinkedHashMap<Integer,Integer> bMap=new LinkedHashMap<Integer,Integer>();
//用于返回进行处理后的数据,存储的对应的键和值
LinkedHashMap<Integer,Integer> dealRMap=new LinkedHashMap<Integer,Integer>();
LinkedHashMap<Integer,Integer> dealGMap=new LinkedHashMap<Integer,Integer>();
LinkedHashMap<Integer,Integer> dealBMap=new LinkedHashMap<Integer,Integer>();
private JPanel CenterJP=null;
private File f =null;
public void init(){
JButton openFile=new JButton("打开文件");
JButton DealPhoto1=new JButton("RGB绘图显示");
JButton DealPhoto3=new JButton("显示处理");
JButton DealPhoto2=new JButton("数据入库");
openFile.addActionListener(this);
DealPhoto1.addActionListener(this);
DealPhoto2.addActionListener(this);
DealPhoto3.addActionListener(this);
frame=new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(900,1000);
frame.setLayout(new BorderLayout());
//操作数据按钮
JPanel OpearJP=new JPanel(new FlowLayout(FlowLayout.LEFT));
frame.add(OpearJP,BorderLayout.NORTH);
OpearJP.setBorder(BorderFactory.createTitledBorder("操作"));
OpearJP.setPreferredSize(new Dimension(900,50));
OpearJP.add(DealPhoto1);
OpearJP.add(DealPhoto3);
OpearJP.add(DealPhoto2);
//用于显示图片的主面板
JPanel ShowJP=new JPanel(new BorderLayout());
ShowJP.setBorder(BorderFactory.createTitledBorder("显示"));
ShowJP.setPreferredSize(new Dimension(900,950));
frame.add(ShowJP,BorderLayout.CENTER);
//用于显示打开一个文件的操作
JPanel NorthJP=new JPanel(new FlowLayout(FlowLayout.LEFT));
ShowJP.add(NorthJP,BorderLayout.NORTH);
NorthJP.setPreferredSize(new Dimension(900,50));
NorthJP.add(openFile);//打开一个文件
//用于显示被操作对象的和绘制的结果图片
CenterJP=new JPanel(new GridLayout(2,2,10,10));
CenterJP.setPreferredSize(new Dimension(900,900));
ShowJP.add(CenterJP,BorderLayout.CENTER);
//加入初始图片
//CenterJP.add(label);
frame.setVisible(true);
}
//实现按钮监听事件
public void actionPerformed(ActionEvent e){
String ButtonName=e.getActionCommand();
if(ButtonName.equals("打开文件")){
CenterJP.removeAll();
//CenterJP.repaint();
System.out.println("打开文件:");
//每次打开文件夹后清除一下存储
rList.clear();
gList.clear();
bList.clear();
rMap.clear();
gMap.clear();
bMap.clear();
dealRMap.clear();
dealGMap.clear();
dealBMap.clear();
openFile();//打开文件
CenterJP.add(label);
CenterJP.updateUI();//更新组件不然不显示;
}else if(ButtonName.equals("RGB绘图显示")){
System.out.println("RGB绘制显示");
OpearDeal1(bi);//处理图片获取绘制图片的数据
//把map中的数据绘制出来,显示在JPanel上
System.out.println("开始绘制rgb的图形");
String flag="r";
ChartPanel rPanel=(new CountDeal()).getPanel(rMap,flag);
CenterJP.add(rPanel);
System.out.println("r绘制完成");
flag="g";
ChartPanel gPanel=(new CountDeal()).getPanel(gMap,flag);
CenterJP.add(gPanel);
System.out.println("g绘制完成");
flag="b";
ChartPanel bPanel=(new CountDeal()).getPanel(bMap,flag);
CenterJP.add(bPanel);
System.out.println("b绘制完成");
CenterJP.updateUI();
//对采集的数据进行绘制
}else if(ButtonName.equals("显示处理")){
System.out.println("显示处理");
dealRMap=new DealInsertMap().dealShowMap(rMap);
dealGMap=(new DealInsertMap()).dealShowMap(gMap);
dealBMap=(new DealInsertMap()).dealShowMap(bMap);
String flag="r";
ChartPanel rPanel=(new CountDeal()).getPanel(dealRMap,flag);
CenterJP.add(rPanel);
System.out.println("r绘制完成");
flag="g";
ChartPanel gPanel=(new CountDeal()).getPanel(dealGMap,flag);
CenterJP.add(gPanel);
System.out.println("g绘制完成");
flag="b";
ChartPanel bPanel=(new CountDeal()).getPanel(dealBMap,flag);
CenterJP.add(bPanel);
System.out.println("b绘制完成");
CenterJP.updateUI();
}else if(ButtonName.equals("数据入库")){
//int flag=400;//用于设置阈值
System.out.println("数据入库");
//获取当前文件的名称;
String names=f.getName();
String name=names.substring(0,names.lastIndexOf('.'));
System.out.println(name);
//(new SqlDate(name)).insertDate(rMap,gMap,bMap);
//(new SqlDate(name)).insertRGBDate(dealRMap,dealGMap,dealBMap);
}
}
//打开文件夹操作
public void openFile(){
JFileChooser chooser=new JFileChooser();
chooser.showOpenDialog(frame);//在某个容器上打开一个文件选择器
f = chooser.getSelectedFile();
//String FilePath=f.getAbsolutePath();
//文件是否存在或者是否选择
if(f == null) {
return;
}
try {
bi = ImageIO.read(f);
/*获取文件是否为图片，如果能够正常的获取到一张图片的宽高属性，
那肯定这是一张图片，因为非图片文件是获取不到它的宽高属性的*/
if(bi == null || bi.getHeight() <=0 || bi.getWidth() <=0){
label.setText("您选择的不是一张图片，请从新选择！");
return;
} else {
String path = f.getPath();
System.out.println(path);
ImageIcon image = new ImageIcon(path);
label.setIcon(image); //设置JLabel的显示图片
//frame.pack();//使此窗口的大小适合其子组件的首选大小和布局。
//frame.validate(); //验证此容器及其所有子组件。
}
} catch (IOException e) {
//e.printStackTrace();
return;
}
}
//处理图片获取对应的RGB值并存储数据
public void OpearDeal1(BufferedImage bi){
int w=bi.getWidth();
int h=bi.getHeight();
int[][] gray=new int[w][h];
for(int x=0;x<w;x++){
for(int y=0;y<h;y++){
int pixel=bi.getRGB(x,y);
int r=(int)(pixel&0xff0000)>>16;
int g=(int)(pixel&0xff00)>>8;
int b=(int)(pixel&0xff);
if(r>=230&&g>=230&&b>=230){
}else{
rList.add(r);
gList.add(g);
bList.add(b);
}
}
}
System.out.println("数据存入成功");
//然后对数据进行处理,存储到map中,
rMap=new DealInsertMap().Deal(rList);
gMap=new DealInsertMap().Deal(gList);
bMap=new DealInsertMap().Deal(bList);
/*Set<Integer> key=rMap.keySet();
java.util.List<Integer> list=new ArrayList<>(key);
for(int i=0;i<key.size();i++){
System.out.println("键的数值为:"+rMap.get(list.get(i)));
}*/
System.out.println("map中分析完成");
}
public static void main(String[] args){
(new MainDemo()).init();
}
}DealInsertMap
import java.util.*;
public class DealInsertMap{
//用于处理采集的RGB数据
public LinkedHashMap<Integer,Integer> Deal(ArrayList<Integer> dealList){
LinkedHashMap<Integer,Integer> dealMap=new LinkedHashMap<Integer,Integer>();
for(int i=0;i<dealList.size();i++){
int key=dealList.get(i);//返回指定的键
//如果不在就创建一个,如果在指定键的值加1
Set<Integer> mapSet=dealMap.keySet();//返回所有的键的集合
//System.out.println("长度大小"+mapSet.size());
if(mapSet.contains(key)){//如果包含该元素,取出加1
int value=dealMap.get(key);
value++;
dealMap.put(key,value);
}else{//如果不存在该元素,创建一个新的元素
dealMap.put(key,1);
}
}
//返回的key是乱序的,需要对该key进行重新排序
LinkedHashMap<Integer,Integer> dealMaps=new LinkedHashMap<Integer,Integer>();
Set<Integer> keys=dealMap.keySet();
ArrayList<Integer> list=new ArrayList<Integer>(keys);
Collections.sort(list);//对list进行排序
for(int i=0;i<list.size();i++){
int value=dealMap.get(list.get(i));
dealMaps.put(list.get(i),value);
}
/*for(Iterator<Integer> it=dealMaps.keySet().iterator();it.hasNext();){
int key=it.next();
System.out.println("key"+key+",value="+dealMaps.get(key));
}*/
System.out.println("list的长度为:"+dealList.size());
System.out.println("map的长度为:"+dealMaps.size());
return dealMaps;
}
/*public static void main(String[] args){
LinkedHashMap<Integer,Integer> dealMap=new LinkedHashMap<Integer,Integer>();
dealMap.put(1,10);
dealMap.put(3,30);
new DealInsertMap().dealShowMap(dealMap);
}*/
//用于对map中的数据进行微分化处理
public LinkedHashMap<Integer,Integer> dealShowMap(LinkedHashMap<Integer,Integer> map){
LinkedHashMap<Integer,Integer> dealMap=new LinkedHashMap<Integer,Integer>();
Set<Integer> keys=map.keySet();
ArrayList<Integer> listKey=new ArrayList<Integer>(keys);
///Iterator<Integer> iterator=keys.iterator();
for(int j=0;j<listKey.size();j++){
int key=listKey.get(j);
//System.out.println("键为:"+key);
int value=map.get(key);
if((j==0)||(j==listKey.size()-1)){//处理第一个和最后一个元素
System.out.println("满足条件的可以"+key);
if(j==0){
dealMap.put(key,value);
}
}else{//找满足的差值,把满足的加入,同时
int reValue=map.get(listKey.get(j-1));
int laValue=map.get(listKey.get(j+1));
if((value>(reValue+30))&&(value>(laValue+30))){
dealMap.put(key,value);
dealMap.put((listKey.get(j+1)),0);//把下一点设为0,并加入
j++;//在移动一步
}
}
}
/*Set<Integer> keyss=dealMap.keySet();
System.out.println("keys:"+keyss);
Iterator<Integer> iterators=keyss.iterator();
while(iterators.hasNext()){
int keysss=iterators.next();
System.out.println("key:"+keysss+",value+"+dealMap.get(keysss));
}*/
return dealMap;
}
}CountDeal
import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.RefineryUtilities;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import java.util.*;
public class CountDeal{
public ChartPanel getPanel(LinkedHashMap<Integer,Integer> dealMap,String flag){
String chartTitle =null;
String x="";
String y="种类个数对于的数量";
String name="";
if(flag.equals("r")){
chartTitle ="r的曲线";
x="r存在的种类个数";
name="r";
}else if(flag.equals("g")){
chartTitle="g的曲线";
x="g存在的种类个数";
name="g";
}else if(flag.equals("b")){
chartTitle="b的曲线";
x="b存在的种类个数";
name="b";
}
JFreeChart lineChart=ChartFactory.createLineChart(
chartTitle,x,y,
createDataset(dealMap,name),
PlotOrientation.VERTICAL,
true,true,false);
ChartPanel chartPanel=new ChartPanel(lineChart);
chartPanel.setPreferredSize(new java.awt.Dimension(400,400));
return chartPanel;
}
//创建数据集
private DefaultCategoryDataset createDataset(LinkedHashMap<Integer,Integer> dealMap,String name){
DefaultCategoryDataset dataset=new DefaultCategoryDataset();
Set<Integer> key=dealMap.keySet();
List<Integer> list=new ArrayList<>(key);
for(int i=0;i<key.size();i++){
dataset.addValue(dealMap.get(list.get(i)),name,list.get(i).toString());
//if(dealMap.get(list.get(i))>100){
//System.out.println("map的值:"+dealMap.get(list.get(i)));
//}
}
return dataset;
}
}
SqlDate
import java.sql.*;
import java.util.*;
public class SqlDate{
private static String root="rootes";
private static String password="123456";
private static String name="com.mysql.jdbc.Driver";
private static String url="jdbc:mysql://192.168.65.99/test";
private static Connection conn=null;
private static Statement stat=null;
private static String typename="";
public SqlDate(String typename){
this.typename=typename;
}
public static Connection getConnection(){
try{
Class.forName(name);
conn=DriverManager.getConnection(url,root,password);
}catch(Exception e){
System.out.println("连接数据库失败");
e.printStackTrace();
}
return conn;
}
/*public static void main(String[] args){
LinkedHashMap<Integer,Integer> hash=new LinkedHashMap<Integer,Integer>();
hash.put(1,10);
hash.put(2,15);
hash.put(3,50);
hash.put(4,100);
hash.put(5,20);
hash.put(6,80);
insertDate(hash,hash,hash);
}
public static void insertRGBDate(LinkedHashMap<Integer,Integer> rMap,
LinkedHashMap<Integer,Integer> gMap,LinkedHashMap<Integer,Integer> bMap){
int countR=dealHashMap(rMap);
int countG=dealHashMap(gMap);
int countB=dealHashMap(bMap);
//对获取的数据进行插入处理;
try{
conn=getConnection();
stat=conn.createStatement();
String sql="insert into tb_rgbcount(type,rcount,gcount,bcount)"+
" values('"+typename+"',"+countR+","+countG+","+countB+")";
stat.execute(sql);
System.out.println("数据插入完成");
}catch(Exception e){
System.out.println("数据库连接失败");
e.printStackTrace();
}
}*/
public static void insertDate(LinkedHashMap<Integer,Integer> rMap,
LinkedHashMap<Integer,Integer> gMap,LinkedHashMap<Integer,Integer> bMap){
int countR=dealHashMap(rMap);
int countG=dealHashMap(gMap);
int countB=dealHashMap(bMap);
//对获取的数据进行插入处理;
try{
conn=getConnection();
stat=conn.createStatement();
String sql="insert into tb_rgbcount(type,rcount,gcount,bcount)"+
" values('"+typename+"',"+countR+","+countG+","+countB+")";
stat.execute(sql);
System.out.println("数据插入完成");
}catch(Exception e){
System.out.println("数据库连接失败");
e.printStackTrace();
}
}
public static int dealHashMap(LinkedHashMap<Integer,Integer> rgbMap){
int flag=0;
int center=0;
int count=0;
Collection<Integer> c=rgbMap.values();
Object[] obj=c.toArray();
Arrays.sort(obj);//对获取的值内容进行由小到大排序
center=((int)obj[0]+(int)obj[obj.length-1])/2;
Set<Integer> keys=rgbMap.keySet();
Iterator<Integer> iterator=keys.iterator();
while(iterator.hasNext()){
int key=iterator.next();
int value=rgbMap.get(key);
if(value>=center){
count=count+(value-center);
}
}
return count;
}
}以上思路只是部分,如果后期还做,会不断升化,这里的阈值在提取微分图像的时候,可以根据需求设置,形成不同的效果.
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
