sudoku.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 1,029 行 · 第 1/3 页

							ae = new AddEntity(gridOnt, ind, null);
							ae.accept((ChangeVisitor) gridOnt);
							AddIndividualClass ai = new AddIndividualClass(gridOnt, ind, (OWLClass) ent, null);
							ai.accept((ChangeVisitor) gridOnt);
						}
					}
				}
			}
			
			// create value individuals(/classes)
			Set valSet = new HashSet();
			for (int i=1; i<=dimen; i++) {
				String gridValue = SUDOKU_NS+"#"+String.valueOf(i);
				OWLEntity val;
				if (this.useIndividuals) val = gridDF.getOWLIndividual(new URI(gridValue));
				else val = gridDF.getOWLClass(new URI(gridValue));
				valSet.add(val);
				AddEntity ae = new AddEntity(gridOnt, val, null);
				ae.accept((ChangeVisitor) gridOnt);
			}
			// make all values different(/disjoint)
			this.makeDifferent(valSet);
			
			// make owl:Thing a subclass of oneOf(1,2,..param) (/OR each class equivalent to unionOf(1,2..param)
			OWLDescription topConstraint = null;
			if (this.useIndividuals) {
				topConstraint = gridDF.getOWLEnumeration(valSet);				
			}
			else {
				topConstraint = gridDF.getOWLOr(valSet);
			}
			OWLClassAxiom cax = gridDF.getOWLSubClassAxiom(gridDF.getOWLThing(), topConstraint);
			AddClassAxiom ac = new AddClassAxiom(gridOnt, cax, null);
			ac.accept((ChangeVisitor) gridOnt);
			
			// enforce constraints of sudoku puzzle
			// make all sub-grid values distinct
			for (int g=1; g<=dimen; g++) {
				Set subGrid = new HashSet();
				for (int i=1; i<=subdim; i++) {
					for (int j=1; j<=subdim; j++) {
						subGrid.add(grid[g][i][j]);						
					}
				}
				this.makeDifferent(subGrid);
			}
			// make all grid-row values distinct
			for (int g=1; g<=dimen; g+=subdim) {
				for (int row=1; row<=subdim; row++) {
					Set gridRow = new HashSet();
					for (int sg=g; sg<=(g+subdim-1); sg++) {
						for (int col=1; col<=subdim; col++) {
							gridRow.add(grid[sg][row][col]);							
						}
					}
					this.makeDifferent(gridRow);					
				}				
			}
			// make all grid-column values distinct
			for (int g=1; g<=subdim; g++) {
				for (int col=1; col<=subdim; col++) {
					Set gridCol = new HashSet();
					for (int sg=g; sg<=dimen; sg+=subdim) {
						for (int row=1; row<=subdim; row++) {
							gridCol.add(grid[sg][row][col]);							
						}
					}
					this.makeDifferent(gridCol);					
				}				
			}
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return gridOnt;
	}
	
	private void makeDifferent(Set diff) {
		try {
			OWLDataFactory gridDF = gridOnt.getOWLDataFactory();
			if (this.useIndividuals) {
				OWLDifferentIndividualsAxiom dif = gridDF.getOWLDifferentIndividualsAxiom(diff);
				AddIndividualAxiom ai = new AddIndividualAxiom(gridOnt, dif, null);
				ai.accept((ChangeVisitor) gridOnt);
			}
			else {
				OWLDisjointClassesAxiom dis = gridDF.getOWLDisjointClassesAxiom(diff);
				AddClassAxiom ai = new AddClassAxiom(gridOnt, dis, null);
				ai.accept((ChangeVisitor) gridOnt);
			}
		}
		catch (OWLException ex) {
			ex.printStackTrace();
		}
	}
	
	private void makeEqual(Set equ) {
		try {
			OWLDataFactory gridDF = gridOnt.getOWLDataFactory();
			if (this.useIndividuals) {
				OWLSameIndividualsAxiom sam = gridDF.getOWLSameIndividualsAxiom(equ);
				AddIndividualAxiom ai = new AddIndividualAxiom(gridOnt, sam, null);
				ai.accept((ChangeVisitor) gridOnt);
			}
			else {
				OWLEquivalentClassesAxiom eq = gridDF.getOWLEquivalentClassesAxiom(equ);
				AddClassAxiom ai = new AddClassAxiom(gridOnt, eq, null);
				ai.accept((ChangeVisitor) gridOnt);
			}
		}
		catch (OWLException ex) {
			ex.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
		Sudoku sud = new Sudoku(9);
	}

	public void actionPerformed(ActionEvent e) {
		
		try {
			if (e.getSource() == defaultMItem1) {
				// load sample 4X4 puzzle
				try {
					gridOnt = swoopModel.loadOntology(new URI("http://www.mindswap.org/~aditkal/sudoku4X4.owl"));
					this.parseOWLOntToGrid(gridOnt);
					
				}
				catch (Exception ex) {
					ex.printStackTrace();
				}
			}
			else
			if (e.getSource() == defaultMItem2) {
				// load sample 9X9 puzzle
				try {
					gridOnt = swoopModel.loadOntology(new URI("http://www.mindswap.org/~aditkal/sudoku9X9.owl"));
					this.parseOWLOntToGrid(gridOnt);
					
				}
				catch (Exception ex) {
					ex.printStackTrace();
				}
			}
			else
			if (e.getSource() == loadMItem) {
				this.loadOWLGrid();
			}
			else
			if (e.getSource() == saveMItem) {
				this.saveOWLGrid();
			}
			else
			if (e.getSource() == useIndMItem) {
				useClaMItem.setSelected(!useIndMItem.isSelected());
			}
			else
			if (e.getSource() == useClaMItem) {
				useIndMItem.setSelected(!useClaMItem.isSelected());
			}
			else
			if (e.getSource() == viewMItem) {
				viewSource();
			}
			else
		    if (e.getSource() == solBtn) 
				solveSudoku();			
			else 
			if (e.getSource() == clearBtn)
				clearTable();
			else
			if (e.getSource() == swoopMItem)
//				saveGridOntology();
				this.loadGridOntologyToSwoop();
			else if (e.getSource() == changeMItem) 
				changeDimensions();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	private void clearTable() {
		for (int i = 0; i<table.getModel().getRowCount(); i++)
			for (int j = 0; j<table.getModel().getRowCount(); j++)
				table.setValueAt("", i, j);
		table.updateUI();
	}
	
	private void viewSource() {
		// generate and view source of OWL
		this.generatePopulatedSudokuOWLGrid();
		JFrame popup = new JFrame("View Source");
		Container content  = popup.getContentPane();
		content.setLayout(new GridLayout(1,1));
		XmlEditorPane xmlPane = new XmlEditorPane();
		xmlPane.setEditable(false);
		xmlPane.setContentType("text/xml");
		xmlPane.setText(this.getRDFXMLGridOnt());
		xmlPane.setCaretPosition(0);
		content.add(new JScrollPane(xmlPane));
		popup.setSize(600, 400);
		popup.setLocation(200, 200);
		popup.show();
	}
	
	private void solveSudoku() {
		
		// generate gridOnt OWL ontology based on puzzle UI
		this.generatePopulatedSudokuOWLGrid();
		
		// use Pellet to get solution to puzzle
		SwingWorker worker = new SwingWorker() {
			PelletReasoner pellet = new PelletReasoner();
			boolean fail = false;
			
			public Object construct() {
				try {
					pellet.setOntology(gridOnt);
				} 
				catch (Exception ex) {
					fail = true;
					if( ex != null )
					    throw new RuntimeException(ex.getMessage());
					else
					    throw new RuntimeException( "Unexpected error" );
				}	
				return null;
			}
			public void finished() {
				if (fail) {											
				}
				else {
					// pellet has got answers
					try {
						if (pellet.isConsistent()) {
							boolean incomplete = false;
							for (int g=1; g<=dimen; g++) {
								for (int i=1; i<=subdim; i++) {
									for (int j=1; j<=subdim; j++) {
										OWLEntity ent = null;
										if (useIndividuals) ent = gridOnt.getClass(new URI(SUDOKU_NS+"#C"+ String.valueOf(g) + "_" + String.valueOf(i) + String.valueOf(j)));
										else ent = gridOnt.getIndividual(new URI(SUDOKU_NS+"#V"+ String.valueOf(g) + "_" + String.valueOf(i) + String.valueOf(j)));
										Set equ = new HashSet();
										if (useIndividuals) equ = pellet.allInstancesOf((OWLClass) ent);
										else {
//											if (!pellet.isConsistent(cla)) {
//												JOptionPane.showMessageDialog(null, "Invalid Data: Puzzle Constraints Violated", "Error", JOptionPane.ERROR_MESSAGE);
//												return;
//											}
											equ = SetUtils.union(pellet.allTypesOf((OWLIndividual) ent)); 											
										}
										
										String val = "";
										for (Iterator iter = equ.iterator(); iter.hasNext();) {
											OWLEntity eq = (OWLEntity) iter.next();
											if (eq.getURI().toString().indexOf("#V")==-1 && eq.getURI().toString().indexOf("#C")==-1 && eq.getURI().toString().indexOf("#T")==-1) {
												val = eq.getURI().toString();
												val = val.substring(val.indexOf("#")+1, val.length());
												break;
											}												
										}
										// translate g,i,j to (row, col)
										int row = ((g - 1) / subdim) * subdim + i;
										int c = g % subdim;
										if (c==0) c = subdim;
										int col = (c-1) * subdim + j;
//											System.out.println(g+"_"+String.valueOf(i)+String.valueOf(j)+" translates to "+"("+row+","+col+")");
										if (table.getValueAt(row-1, col-1) == null || table.getValueAt(row-1, col-1).toString().equals("") && !val.equals("")) changed = true;
										table.setValueAt(val, row-1, col-1);
										if (val.equals("")) incomplete = true;
										
										table.updateUI();
									}
								}								
							}
							//FIXME: iteratively solve sudoku if using classes?!
//							if (!useIndividuals && incomplete && changed) {
//								changed = false;
//								generatePopulatedSudokuOWLGrid();
//								solveSudoku();
//							}
						}
						else {
							JOptionPane.showMessageDialog(null, "Invalid Data: Puzzle Constraints Violated", "Error", JOptionPane.ERROR_MESSAGE);
						}
					}
					catch (Exception ex) {
						ex.printStackTrace();
					}
				}
			}
		};				
	    worker.start();
	}
	
	private void loadOWLGrid() {
		try {
			// prompt user for file
			JFileChooser wrapChooser = new JFileChooser();
//			wrapChooser.addChoosableFileFilter();
			File openFile = null;
			int returnVal = wrapChooser.showOpenDialog(this);
			if (returnVal == JFileChooser.APPROVE_OPTION) {
				openFile = wrapChooser.getSelectedFile();
			} else { // open cancelled
					return;
			}
			// open file
			FileInputStream in = new FileInputStream(openFile);
			InputStreamReader reader = new InputStreamReader(in);
			URI uri = new URI(openFile.getName());
			gridOnt = swoopModel.loadOntologyInRDF(reader, uri);
			this.parseOWLOntToGrid(gridOnt);
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	private void parseOWLOntToGrid(OWLOntology gridOnt) {
		
		try {
			
			// first get used classes or individuals
			Set uris = OntologyHelper.allURIs(gridOnt);
			boolean usedInd = false;
			for (Iterator iter = uris.iterator(); iter.hasNext();) {
				URI u = (URI) iter.next();
				if (u.toString().indexOf("#V")>=0) {
					usedInd = true;
					break;
				}
			}
			this.useIndividuals = usedInd;
			this.useIndMItem.setSelected(usedInd);
			this.useClaMItem.setSelected(!usedInd);
			
			// second get grid dimensions
			int num = 0;
			for (int i=10; i>0; i--) {