package ng.Algorithm.Layouts;
|
|
|
import java.lang.reflect.Array;
|
import java.sql.*;
|
import java.util.*;
|
|
import org.json.JSONArray;
|
import org.json.JSONException;
|
import org.json.JSONObject;
|
|
import ng.Algorithm.Layouts.Heuristic.RowResult;
|
import ng.Algorithm.Layouts.LayoutAlgorithm.AlgorithmParams;
|
|
public class AlgorithmDBInterface {
|
|
private String connectionString;
|
private int workId;
|
public AlgorithmDBInterface(String connectionString,int WorkId){
|
this.connectionString=connectionString;
|
this.workId=WorkId;
|
param_sql=String.format("SELECT `width`,`length`,`xinterval`,`yinterval` from gmms_furnace where id=%d", WorkId);
|
this.peice_sql=String.format("select id,processcard,position,front,width,height,glass_idx,thickness,color,layout_mode,w,h from tempere_task_glass where work_id=%d", WorkId);
|
}
|
|
private String param_sql;
|
private String peice_sql;
|
|
public int Line;
|
|
public boolean canr=true;
|
|
|
private AlgorithmParams getParam(Connection con) throws SQLException{
|
Statement sm= con.createStatement();
|
ResultSet rs= sm.executeQuery(param_sql);
|
rs.next();
|
AlgorithmParams p=new AlgorithmParams();
|
p.width=rs.getInt(1);
|
p.length=rs.getInt(2);
|
p.h_interval=rs.getInt(3);
|
p.v_interval=rs.getInt(4);
|
p.method="Heuristic";
|
rs.close();
|
sm.close();
|
return p;
|
}
|
|
class Info {
|
public long id;
|
public int thicknss;
|
public String color;
|
public int width;
|
public int height;
|
public Piece.LayoutMode layout_mode;
|
public int FrameNumber;
|
public boolean IsFront;
|
public int GlassIndex;
|
public String Processcard;
|
public int GlassNumber;
|
public double w,h;
|
@Override
|
public String toString(){
|
return String.format("%d.%d[%d]",FrameNumber,GlassNumber,id);
|
}
|
|
}
|
|
compare piececompare=new compare();
|
|
|
class compare implements java.util.Comparator<Piece>{
|
|
@Override
|
public int compare(Piece arg0, Piece arg1) {
|
// TODO Auto-generated method stub
|
Info info1=(Info)arg0.Source;
|
Info info2=(Info)arg1.Source;
|
int a1=info1.IsFront?0:1;
|
int a2=info2.IsFront?0:1;
|
if(a1>a2)
|
return -1;
|
if(a1<a2)
|
return 1;
|
if(info1.GlassIndex<info2.GlassIndex)
|
return 1;
|
if(info1.GlassIndex>info2.GlassIndex)
|
return -1;
|
return 0;
|
}
|
|
}
|
|
|
|
private Info[] toInfo(ResultSet set,boolean canRotate) throws SQLException{
|
List<Info> list=new ArrayList<Info>();
|
while(set.next()){
|
Info info=new Info();
|
info.id=set.getLong("id");
|
info.thicknss= (int)set.getDouble("thickness");
|
info.color=set.getString("color");
|
info.width=(int)set.getDouble("width");
|
info.height=(int)set.getDouble("height");
|
info.Processcard=set.getString("processcard");
|
double w=set.getDouble("w");
|
double h=set.getDouble("h");
|
info.w=w;
|
info.h=h;
|
if(canRotate==true){
|
info.layout_mode=Piece.LayoutMode.Both;
|
}
|
else{
|
info.layout_mode=w<h?Piece.LayoutMode.Zhong:Piece.LayoutMode.Heng;
|
}
|
|
/*
|
int mode=set.getInt("layout_mode");
|
switch(mode){
|
case 1:
|
info.layout_mode= Piece.LayoutMode.Zhong;
|
break;
|
case 2:
|
info.layout_mode=Piece.LayoutMode.Heng;
|
break;
|
default:
|
info.layout_mode=Piece.LayoutMode.Both;
|
break;
|
}
|
*/
|
info.FrameNumber=set.getInt("position");
|
info.IsFront=set.getInt("front")==1;
|
info.GlassIndex=set.getInt("glass_idx");
|
list.add(info);
|
; }
|
Info[] ret=new Info[list.size()];
|
return list.toArray(ret);
|
}
|
|
|
|
private List<Piece>[] getPiece(Connection con,boolean canRotate) throws SQLException{
|
Statement sm= con.createStatement();
|
ResultSet rs= sm.executeQuery(this.peice_sql);
|
ArrayList<ArrayList<Piece>> pss=new ArrayList<ArrayList<Piece>>();
|
Info[] infos=toInfo(rs,canRotate);
|
if(infos==null)
|
return null;
|
if(infos.length==0)
|
return null;
|
rs.close();
|
sm.close();
|
for(int i=0;i<infos.length;i++){
|
Info cur=infos[i];
|
Piece p=new Piece();
|
p.width=cur.width;
|
p.height=cur.height;
|
p.Mode=cur.layout_mode;
|
p.Source=cur;
|
p.w=cur.w;
|
p.h=cur.h;
|
boolean ok=false;
|
for(int j=0;j<pss.size();j++){
|
Piece pp=pss.get(j).get(0);
|
Info info=(Info)pp.Source;
|
if(info.FrameNumber==cur.FrameNumber){
|
pss.get(j).add(p);
|
ok=true;
|
break;
|
}
|
}
|
if(ok==false){
|
ArrayList<Piece> pl=new ArrayList<Piece>();
|
pl.add(p);
|
pss.add(pl);
|
}
|
}
|
for(int i=0;i<pss.size();i++){
|
pss.get(i).sort(this.piececompare);
|
List<Piece> list=pss.get(i);
|
for(int j=0;j<list.size();j++){
|
Info info= (Info)list.get(j).Source;
|
info.GlassNumber=j+1;
|
}
|
}
|
List<Piece> p=new ArrayList<Piece>();
|
List<Piece>[] ret=(List<Piece>[])Array.newInstance(p.getClass(), pss.size());
|
for(int i=0;i<ret.length;i++){
|
ret[i]=pss.get(i);
|
}
|
return ret;
|
}
|
|
|
|
|
|
|
|
private void saveLayout(Connection con,LayoutResult result,AlgorithmParams param) throws SQLException {
|
int step=0;
|
try {
|
con.setAutoCommit(false);
|
int number=result.Number;
|
step=1;
|
CallableStatement call= con.prepareCall("{call insert_tempere_layout(?,?,?,?,?,?,?,?,?,?,?,?,?,?)}");
|
boolean ok=true;
|
for(int i=0;i<result.layout.length;i++){
|
Rect r=result.layout[i];
|
Info info=(Info)r.getSource().Source;
|
int move=0;
|
int pendulum=1;
|
if(i==result.layout.length-1){
|
pendulum=3;
|
}
|
else{
|
if(result.layout[i].Row!=result.layout[i+1].Row)
|
pendulum=2;
|
}
|
|
|
if(pendulum!=1){
|
move=param.width-result.layout[i].x;
|
}
|
else{
|
move=result.layout[i+1].x-result.layout[i].x;
|
}
|
|
call.setInt(1,this.workId);
|
call.setInt(2,number);
|
call.setDouble(3,result.rate);
|
call.setInt(4,i+1);
|
call.setInt(5,r.x);
|
call.setInt(6,r.y);
|
if(r.getLength()==r.getWidth()){
|
call.setInt(7,0);
|
}else{
|
call.setInt(7,r.isHeng?0:1);
|
}
|
|
call.setInt(8, pendulum);
|
call.setInt(9,move);
|
call.setInt(10, r.Row);
|
call.setInt(11,r.Col);
|
call.setLong(12,info.id);
|
call.setString(13, null);
|
call.registerOutParameter(14,java.sql.Types.INTEGER);
|
call.execute();
|
if(call.getInt(14)!=1){
|
ok=false;
|
break;
|
}
|
|
}
|
if(ok){
|
con.commit();
|
}
|
else{
|
con.rollback();
|
}
|
con.close();
|
|
} catch (SQLException e) {
|
if(step>=1)
|
con.rollback();
|
con.close();
|
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
|
}
|
|
public LayoutResult lastResult;
|
|
public class ComputeResult{
|
public Exception Error;
|
public boolean Success;
|
public int Number;
|
public boolean isNothing;
|
public LayoutResult Result;
|
public String toJson(){
|
|
try{
|
JSONArray arr=new JSONArray();
|
for(int i=0;i<Result.layout.length;i++){
|
Rect r=Result.layout[i];
|
JSONObject obj=new JSONObject();
|
obj.put("x",r.x);
|
obj.put("y",r.y);
|
obj.put("w",r.getXSize());
|
obj.put("h",r.getYSize());
|
obj.put("size",""+r.getSource().w+"*"+r.getSource().h);
|
int k=0;
|
if(r.canHeng()){
|
k=2;
|
}
|
if(r.canZhong()){
|
k+=1;
|
}
|
obj.put("mode",k);
|
arr.put(obj);
|
}
|
return arr.toString();
|
}
|
catch(Exception e){
|
return "{}";
|
}
|
}
|
}
|
|
|
|
int getNextLayoutNumber(Connection con) throws SQLException{
|
CallableStatement sm= con.prepareCall("{call get_next_tempere_number(?,?)}");
|
sm.setInt(1,this.workId);
|
sm.registerOutParameter(2,java.sql.Types.INTEGER);
|
|
int ret=0;
|
sm.execute();
|
ret=sm.getInt(2);
|
sm.close();
|
return ret;
|
}
|
|
|
public ComputeResult ComputeOnce(boolean canRotate){
|
Connection con=null;
|
lastResult=null;
|
try {
|
con = java.sql.DriverManager.getConnection(this.connectionString);
|
AlgorithmParams param=getParam(con);
|
List<Piece>[] ps=getPiece(con,canRotate);
|
if(ps==null){
|
ComputeResult ret= new ComputeResult();
|
ret.Success=false;
|
ret.Number=0;
|
ret.Error=null;
|
ret.isNothing=true;
|
con.close();
|
return ret;
|
}
|
LayoutResult result= LayoutAlgorithm.Compute(param,ps);
|
int number= getNextLayoutNumber(con);
|
result.WorkId=this.workId;
|
result.Number=number;
|
if(result!=null){
|
this.saveLayout(con, result,param);
|
this.lastResult=result;
|
ComputeResult ret= new ComputeResult();
|
ret.Success=true;
|
ret.Number=number;
|
ret.Error=null;
|
ret.isNothing=false;
|
ret.Result=result;
|
return ret;
|
}
|
ComputeResult ret1= new ComputeResult();
|
ret1.Success=false;
|
ret1.Number=0;
|
ret1.Error=null;
|
ret1.isNothing=true;
|
con.close();
|
return ret1;
|
|
} catch (SQLException e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
ComputeResult ret= new ComputeResult();
|
ret.Success=false;
|
ret.Number=0;
|
ret.Error=e;
|
ret.isNothing=false;
|
return ret;
|
}
|
finally{
|
try {
|
con.close();
|
} catch (SQLException e1) {
|
// TODO Auto-generated catch block
|
e1.printStackTrace();
|
}
|
}
|
|
|
}
|
private static AlgorithmDBInterface[] als;
|
public static void initAlgorithm(String connectionString,int[] lines){
|
als=new AlgorithmDBInterface[lines.length];
|
for(int i=0;i<lines.length;i++){
|
als[i]=new AlgorithmDBInterface(connectionString,lines[i]);
|
als[i].Line=lines[i];
|
}
|
}
|
|
public static int getCanRotate(int line){
|
for(int i=0;i<als.length;i++){
|
if(als[i].Line==line)
|
return als[i].canr?1:0;
|
}
|
return -1;
|
}
|
|
public static boolean setCanRotate(int line,boolean rotate){
|
for(int i=0;i<als.length;i++){
|
if(als[i].Line==line){
|
als[i].canr=rotate;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
|
public static ComputeResult ComputeOnce(int line){
|
|
for(int i=0;i<als.length;i++){
|
if(als[i].Line==line)
|
return als[i].ComputeOnce(als[i].canr);
|
}
|
return null;
|
}
|
}
|
