public void backgroundImpl() {
if (backgroundAlpha) {
// Create a small array that can be used to set the pixels several times.
// Using a single-pixel line of length 'width' is a tradeoff between
// speed (setting each pixel individually is too slow) and memory
// (an array for width*height would waste lots of memory if it stayed
// resident, and would terrify the gc if it were re-created on each trip
// to background().
WritableRaster raster = ((BufferedImage) image).getRaster();
if ((clearPixels == null) || (clearPixels.length < width)) {
clearPixels = new int[width];
}
java.util.Arrays.fill(clearPixels, backgroundColor);
for (int i = 0; i < height; i++) {
raster.setDataElements(0, i, width, 1, clearPixels);
}
} else {
// new Exception().printStackTrace(System.out);
// in case people do transformations before background(),
// need to handle this with a push/reset/pop
pushMatrix();
resetMatrix();
g2.setColor(new Color(backgroundColor)); // , backgroundAlpha));
g2.fillRect(0, 0, width, height);
popMatrix();
}
}
@Override
public void actionPerformed(ActionEvent e) {
if (lastSelected == null) {
return;
}
defaulted.add(lastSelected);
BibtexEntryType type = BibtexEntryType.getStandardType(lastSelected);
if (type != null) {
String[] rf = type.getRequiredFieldsForCustomization(), of = type.getOptionalFields();
List<String> req, opt1, opt2;
if (rf != null) {
req = java.util.Arrays.asList(rf);
} else {
req = new ArrayList<String>();
}
opt1 = new ArrayList<String>();
opt2 = new ArrayList<String>();
if (biblatexMode) {
if (of != null) {
String[] priOptArray = type.getPrimaryOptionalFields();
String[] secOptArray = Util.getRemainder(of, priOptArray);
if (priOptArray != null) {
opt1 = java.util.Arrays.asList(priOptArray);
}
if (secOptArray != null) {
opt2 = java.util.Arrays.asList(secOptArray);
}
}
} else {
if (of != null) {
opt1 = java.util.Arrays.asList(of);
}
}
reqComp.setFields(req);
reqComp.setEnabled(true);
optComp.setFields(opt1);
if (biblatexMode) {
optComp2.setFields(opt2);
}
}
}
public boolean equals(Object other) {
if (other == this) {
return true;
}
if (!(other instanceof QTNode)) {
return false;
}
QTNode comparee = (QTNode) other;
return super.equals(other) && java.util.Arrays.equals(children, comparee.children);
}
public com.kingdee.bos.ctrl.swing.KDToolBar[] getUIMultiToolBar() {
java.util.List list = new java.util.ArrayList();
com.kingdee.bos.ctrl.swing.KDToolBar[] bars = super.getUIMultiToolBar();
if (bars != null) {
list.addAll(java.util.Arrays.asList(bars));
}
list.add(this.toolBar);
return (com.kingdee.bos.ctrl.swing.KDToolBar[])
list.toArray(new com.kingdee.bos.ctrl.swing.KDToolBar[list.size()]);
}
public void actionPerformed(ActionEvent event) {
int action = Integer.parseInt(event.getActionCommand());
switch (action) {
case DELETE:
model.removeAll(java.util.Arrays.asList(list.getSelectedValues()));
break;
case ADD:
if (callback != null) callback.actionPerformed(event);
else {
activeView.reset();
activeView.init(activeElement);
addElementPanel.setVisible(true);
}
break;
case CANCEL:
addElementPanel.setVisible(false);
break;
case ADD_ELEMENT:
if (activeView != null) model.add(activeView.getElement());
break;
}
}
public class EntryCustomizationDialog2 extends JDialog
implements ListSelectionListener, ActionListener {
private final JabRefFrame frame;
protected GridBagLayout gbl = new GridBagLayout();
protected GridBagConstraints con = new GridBagConstraints();
private FieldSetComponent reqComp;
private FieldSetComponent optComp;
private FieldSetComponent optComp2;
private EntryTypeList typeComp;
private JButton ok;
private JButton cancel;
private JButton apply;
protected JButton helpButton;
protected JButton delete;
protected JButton importTypes;
protected JButton exportTypes;
private final List<String> preset = java.util.Arrays.asList(BibtexFields.getAllFieldNames());
private String lastSelected = null;
private final Map<String, List<String>> reqLists = new HashMap<String, List<String>>();
private final Map<String, List<String>> optLists = new HashMap<String, List<String>>();
private final Map<String, List<String>> opt2Lists = new HashMap<String, List<String>>();
private final Set<String> defaulted = new HashSet<String>();
private final Set<String> changed = new HashSet<String>();
private boolean biblatexMode;
/** Creates a new instance of EntryCustomizationDialog2 */
public EntryCustomizationDialog2(JabRefFrame frame) {
super(frame, Globals.lang("Customize entry types"), false);
this.frame = frame;
initGui();
}
private void initGui() {
Container pane = getContentPane();
pane.setLayout(new BorderLayout());
biblatexMode = Globals.prefs.getBoolean("biblatexMode");
JPanel main = new JPanel(), buttons = new JPanel(), right = new JPanel();
main.setLayout(new BorderLayout());
right.setLayout(new GridLayout(biblatexMode ? 2 : 1, 2));
java.util.List<String> entryTypes = new ArrayList<String>();
for (String s : BibtexEntryType.ALL_TYPES.keySet()) {
entryTypes.add(s);
}
typeComp = new EntryTypeList(entryTypes);
typeComp.addListSelectionListener(this);
typeComp.addAdditionActionListener(this);
typeComp.addDefaultActionListener(new DefaultListener());
typeComp.setListSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// typeComp.setEnabled(false);
reqComp =
new FieldSetComponent(
Globals.lang("Required fields"), new ArrayList<String>(), preset, true, true);
reqComp.setEnabled(false);
reqComp.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
ListDataListener dataListener = new DataListener();
reqComp.addListDataListener(dataListener);
optComp =
new FieldSetComponent(
Globals.lang("Optional fields"), new ArrayList<String>(), preset, true, true);
optComp.setEnabled(false);
optComp.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
optComp.addListDataListener(dataListener);
right.add(reqComp);
right.add(optComp);
if (biblatexMode) {
optComp2 =
new FieldSetComponent(
Globals.lang("Optional fields") + " 2", new ArrayList<String>(), preset, true, true);
optComp2.setEnabled(false);
optComp2.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
optComp2.addListDataListener(dataListener);
right.add(new JPanel());
right.add(optComp2);
}
// right.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),
// Globals.lang("Fields")));
right.setBorder(BorderFactory.createEtchedBorder());
ok = new JButton("Ok");
cancel = new JButton(Globals.lang("Cancel"));
apply = new JButton(Globals.lang("Apply"));
ok.addActionListener(this);
apply.addActionListener(this);
cancel.addActionListener(this);
ButtonBarBuilder bb = new ButtonBarBuilder(buttons);
buttons.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
bb.addGlue();
bb.addButton(ok);
bb.addButton(apply);
bb.addButton(cancel);
bb.addGlue();
AbstractAction closeAction =
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
dispose();
}
};
ActionMap am = main.getActionMap();
InputMap im = main.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
im.put(Globals.prefs.getKey("Close dialog"), "close");
am.put("close", closeAction);
// con.fill = GridBagConstraints.BOTH;
// con.weightx = 0.3;
// con.weighty = 1;
// gbl.setConstraints(typeComp, con);
main.add(typeComp, BorderLayout.WEST);
main.add(right, BorderLayout.CENTER);
main.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
pane.add(main, BorderLayout.CENTER);
pane.add(buttons, BorderLayout.SOUTH);
pack();
}
@Override
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) {
return;
}
if (lastSelected != null) {
// The entry type lastSelected is now unselected, so we store the current settings
// for that type in our two maps.
reqLists.put(lastSelected, reqComp.getFields());
optLists.put(lastSelected, optComp.getFields());
if (biblatexMode) {
opt2Lists.put(lastSelected, optComp2.getFields());
}
}
String s = typeComp.getFirstSelected();
if (s == null) {
return;
}
List<String> rl = reqLists.get(s);
if (rl == null) {
BibtexEntryType type = BibtexEntryType.getType(s);
if (type != null) {
String[] rf = type.getRequiredFieldsForCustomization(), of = type.getOptionalFields();
List<String> req, opt;
if (rf != null) {
req = java.util.Arrays.asList(rf);
} else {
req = new ArrayList<String>();
}
if (!biblatexMode) {
if (of != null) {
opt = java.util.Arrays.asList(of);
} else {
opt = new ArrayList<String>();
}
} else {
String[] priOf = type.getPrimaryOptionalFields();
if (priOf != null) {
opt = java.util.Arrays.asList(priOf);
} else {
opt = new ArrayList<String>();
}
List<String> opt2 = new ArrayList<String>();
if (of != null) {
for (String anOf : of) {
if (!opt.contains(anOf)) {
opt2.add(anOf);
}
}
}
optComp2.setFields(opt2);
optComp2.setEnabled(true);
}
reqComp.setFields(req);
reqComp.setEnabled(true);
optComp.setFields(opt);
optComp.setEnabled(true);
} else {
// New entry, veintle
reqComp.setFields(new ArrayList<String>());
reqComp.setEnabled(true);
optComp.setFields(new ArrayList<String>());
optComp.setEnabled(true);
if (biblatexMode) {
optComp2.setFields(new ArrayList<String>());
optComp2.setEnabled(true);
}
new FocusRequester(reqComp);
}
} else {
reqComp.setFields(rl);
optComp.setFields(optLists.get(s));
if (biblatexMode) {
optComp2.setFields(opt2Lists.get(s));
}
}
lastSelected = s;
typeComp.enable(s, changed.contains(lastSelected) && !defaulted.contains(lastSelected));
}
private void applyChanges() {
valueChanged(new ListSelectionEvent(new JList(), 0, 0, false));
// Iterate over our map of required fields, and list those types if necessary:
List<String> types = typeComp.getFields();
for (Map.Entry<String, List<String>> stringListEntry : reqLists.entrySet()) {
if (!types.contains(stringListEntry.getKey())) {
continue;
}
List<String> reqFields = stringListEntry.getValue();
List<String> optFields = optLists.get(stringListEntry.getKey());
List<String> opt2Fields = opt2Lists.get(stringListEntry.getKey());
String[] reqStr = new String[reqFields.size()];
reqStr = reqFields.toArray(reqStr);
String[] optStr = new String[optFields.size()];
optStr = optFields.toArray(optStr);
String[] opt2Str;
if (opt2Fields != null) {
opt2Str = opt2Fields.toArray(new String[opt2Fields.size()]);
} else {
opt2Str = new String[0];
}
// If this type is already existing, check if any changes have
// been made
boolean changesMade = true;
if (defaulted.contains(stringListEntry.getKey())) {
// This type should be reverted to its default setup.
// System.out.println("Defaulting: "+typeName);
String nm = StringUtil.nCase(stringListEntry.getKey());
BibtexEntryType.removeType(nm);
updateTypesForEntries(nm);
continue;
}
BibtexEntryType oldType = BibtexEntryType.getType(stringListEntry.getKey());
if (oldType != null) {
String[] oldReq = oldType.getRequiredFields(), oldOpt = oldType.getOptionalFields();
if (biblatexMode) {
String[] priOpt = oldType.getPrimaryOptionalFields();
String[] secOpt = Util.getRemainder(oldOpt, priOpt);
if (equalArrays(oldReq, reqStr)
&& equalArrays(oldOpt, optStr)
&& equalArrays(secOpt, opt2Str)) {
changesMade = false;
}
} else if (equalArrays(oldReq, reqStr) && equalArrays(oldOpt, optStr)) {
changesMade = false;
}
}
if (changesMade) {
// System.out.println("Updating: "+typeName);
CustomEntryType typ =
biblatexMode
? new CustomEntryType(
StringUtil.nCase(stringListEntry.getKey()), reqStr, optStr, opt2Str)
: new CustomEntryType(StringUtil.nCase(stringListEntry.getKey()), reqStr, optStr);
BibtexEntryType.ALL_TYPES.put(stringListEntry.getKey().toLowerCase(), typ);
updateTypesForEntries(typ.getName());
}
}
Set<Object> toRemove = new HashSet<Object>();
for (String o : BibtexEntryType.ALL_TYPES.keySet()) {
if (!types.contains(o)) {
toRemove.add(o);
}
}
// Remove those that should be removed:
if (!toRemove.isEmpty()) {
for (Object aToRemove : toRemove) {
typeDeletion((String) aToRemove);
}
}
updateTables();
}
private void typeDeletion(String name) {
BibtexEntryType type = BibtexEntryType.getType(name);
if (type instanceof CustomEntryType) {
if (BibtexEntryType.getStandardType(name) == null) {
int reply =
JOptionPane.showConfirmDialog(
frame,
Globals.lang(
"All entries of this " + "type will be declared " + "typeless. Continue?"),
Globals.lang("Delete custom format") + " '" + StringUtil.nCase(name) + '\'',
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE);
if (reply != JOptionPane.YES_OPTION) {
return;
}
}
BibtexEntryType.removeType(name);
updateTypesForEntries(StringUtil.nCase(name));
changed.remove(name);
reqLists.remove(name);
optLists.remove(name);
if (biblatexMode) {
opt2Lists.remove(name);
}
}
// messageLabel.setText("'"+type.getName()+"' "+
// Globals.lang("is a standard type."));
}
private boolean equalArrays(String[] one, String[] two) {
if ((one == null) && (two == null)) {
return true; // Both null.
}
if ((one == null) || (two == null)) {
return false; // One of them null, the other not.
}
if (one.length != two.length) {
return false; // Different length.
}
// If we get here, we know that both are non-null, and that they have the same length.
for (int i = 0; i < one.length; i++) {
if (!one[i].equals(two[i])) {
return false;
}
}
// If we get here, all entries have matched.
return true;
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == ok) {
applyChanges();
dispose();
} else if (e.getSource() == cancel) {
dispose();
} else if (e.getSource() == apply) {
applyChanges();
} else if (e.getSource() == typeComp) {
// System.out.println("add: "+e.getActionCommand());
typeComp.selectField(e.getActionCommand());
}
}
/**
* Cycle through all databases, and make sure everything is updated with the new type
* customization. This includes making sure all entries have a valid type, that no obsolete entry
* editors are around, and that the right-click menus' change type menu is up-to-date.
*/
private void updateTypesForEntries(String typeName) {
if (frame.getTabbedPane().getTabCount() == 0) {
return;
}
for (int i = 0; i < frame.getTabbedPane().getTabCount(); i++) {
BasePanel bp = (BasePanel) frame.getTabbedPane().getComponentAt(i);
// Invalidate associated cached entry editor
bp.entryEditors.remove(typeName);
for (BibtexEntry entry : bp.database().getEntries()) {
entry.updateType();
}
}
}
private void updateTables() {
if (frame.getTabbedPane().getTabCount() == 0) {
return;
}
for (int i = 0; i < frame.getTabbedPane().getTabCount(); i++) {
frame.getTabbedPane().getComponentAt(i);
}
}
// DEFAULT button pressed. Remember that this entry should be reset to default,
// unless changes are made later.
private class DefaultListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
if (lastSelected == null) {
return;
}
defaulted.add(lastSelected);
BibtexEntryType type = BibtexEntryType.getStandardType(lastSelected);
if (type != null) {
String[] rf = type.getRequiredFieldsForCustomization(), of = type.getOptionalFields();
List<String> req, opt1, opt2;
if (rf != null) {
req = java.util.Arrays.asList(rf);
} else {
req = new ArrayList<String>();
}
opt1 = new ArrayList<String>();
opt2 = new ArrayList<String>();
if (biblatexMode) {
if (of != null) {
String[] priOptArray = type.getPrimaryOptionalFields();
String[] secOptArray = Util.getRemainder(of, priOptArray);
if (priOptArray != null) {
opt1 = java.util.Arrays.asList(priOptArray);
}
if (secOptArray != null) {
opt2 = java.util.Arrays.asList(secOptArray);
}
}
} else {
if (of != null) {
opt1 = java.util.Arrays.asList(of);
}
}
reqComp.setFields(req);
reqComp.setEnabled(true);
optComp.setFields(opt1);
if (biblatexMode) {
optComp2.setFields(opt2);
}
}
}
}
class DataListener implements ListDataListener {
@Override
public void intervalAdded(javax.swing.event.ListDataEvent e) {
record();
}
@Override
public void intervalRemoved(javax.swing.event.ListDataEvent e) {
record();
}
@Override
public void contentsChanged(javax.swing.event.ListDataEvent e) {
record();
}
private void record() {
if (lastSelected == null) {
return;
}
defaulted.remove(lastSelected);
changed.add(lastSelected);
typeComp.enable(lastSelected, true);
}
}
}
@Override
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) {
return;
}
if (lastSelected != null) {
// The entry type lastSelected is now unselected, so we store the current settings
// for that type in our two maps.
reqLists.put(lastSelected, reqComp.getFields());
optLists.put(lastSelected, optComp.getFields());
if (biblatexMode) {
opt2Lists.put(lastSelected, optComp2.getFields());
}
}
String s = typeComp.getFirstSelected();
if (s == null) {
return;
}
List<String> rl = reqLists.get(s);
if (rl == null) {
BibtexEntryType type = BibtexEntryType.getType(s);
if (type != null) {
String[] rf = type.getRequiredFieldsForCustomization(), of = type.getOptionalFields();
List<String> req, opt;
if (rf != null) {
req = java.util.Arrays.asList(rf);
} else {
req = new ArrayList<String>();
}
if (!biblatexMode) {
if (of != null) {
opt = java.util.Arrays.asList(of);
} else {
opt = new ArrayList<String>();
}
} else {
String[] priOf = type.getPrimaryOptionalFields();
if (priOf != null) {
opt = java.util.Arrays.asList(priOf);
} else {
opt = new ArrayList<String>();
}
List<String> opt2 = new ArrayList<String>();
if (of != null) {
for (String anOf : of) {
if (!opt.contains(anOf)) {
opt2.add(anOf);
}
}
}
optComp2.setFields(opt2);
optComp2.setEnabled(true);
}
reqComp.setFields(req);
reqComp.setEnabled(true);
optComp.setFields(opt);
optComp.setEnabled(true);
} else {
// New entry, veintle
reqComp.setFields(new ArrayList<String>());
reqComp.setEnabled(true);
optComp.setFields(new ArrayList<String>());
optComp.setEnabled(true);
if (biblatexMode) {
optComp2.setFields(new ArrayList<String>());
optComp2.setEnabled(true);
}
new FocusRequester(reqComp);
}
} else {
reqComp.setFields(rl);
optComp.setFields(optLists.get(s));
if (biblatexMode) {
optComp2.setFields(opt2Lists.get(s));
}
}
lastSelected = s;
typeComp.enable(s, changed.contains(lastSelected) && !defaulted.contains(lastSelected));
}
public List<String> getFields() {
return java.util.Arrays.asList(fields);
}
/**
* Compute final cluster centers for all clusters using K-mean clustering method
*
* @param srcBandList the input bands
* @param tileRectangles Array of rectangles for all source tiles of the image
* @param op the operator
*/
private void computeFinalTerrainClusterCenters(
final double[][] fdd,
final java.util.List<ClusterInfo> pvCenterList,
final java.util.List<ClusterInfo> pdCenterList,
final java.util.List<ClusterInfo> psCenterList,
final PolBandUtils.PolSourceBand srcBandList,
final Rectangle[] tileRectangles,
final PolarimetricClassificationOp op) {
boolean endIteration = false;
final StatusProgressMonitor status =
new StatusProgressMonitor(StatusProgressMonitor.TYPE.SUBTASK);
status.beginTask("Computing Final Cluster Centres... ", tileRectangles.length * maxIterations);
final int pvNumClusters = pvCenterList.size();
final int pdNumClusters = pdCenterList.size();
final int psNumClusters = psCenterList.size();
final int maxNumClusters = Math.max(pvNumClusters, Math.max(pdNumClusters, psNumClusters));
final int[][] clusterCounter = new int[3][maxNumClusters];
final ThreadManager threadManager = new ThreadManager();
try {
for (int it = 0; (it < maxIterations && !endIteration); ++it) {
// System.out.println("Iteration: " + it);
// final long startTime = System.nanoTime();
// final long endTime;
final double[][][] pvSumRe = new double[pvNumClusters][3][3];
final double[][][] pvSumIm = new double[pvNumClusters][3][3];
final double[][][] pdSumRe = new double[pdNumClusters][3][3];
final double[][][] pdSumIm = new double[pdNumClusters][3][3];
final double[][][] psSumRe = new double[psNumClusters][3][3];
final double[][][] psSumIm = new double[psNumClusters][3][3];
java.util.Arrays.fill(clusterCounter[0], 0);
java.util.Arrays.fill(clusterCounter[1], 0);
java.util.Arrays.fill(clusterCounter[2], 0);
for (final Rectangle rectangle : tileRectangles) {
final Thread worker =
new Thread() {
final Tile[] sourceTiles = new Tile[srcBandList.srcBands.length];
final ProductData[] dataBuffers = new ProductData[srcBandList.srcBands.length];
final double[][] Tr = new double[3][3];
final double[][] Ti = new double[3][3];
@Override
public void run() {
op.checkIfCancelled();
final int x0 = rectangle.x;
final int y0 = rectangle.y;
final int w = rectangle.width;
final int h = rectangle.height;
final int xMax = x0 + w;
final int yMax = y0 + h;
final Rectangle sourceRectangle = getSourceRectangle(x0, y0, w, h);
for (int i = 0; i < sourceTiles.length; ++i) {
sourceTiles[i] = op.getSourceTile(srcBandList.srcBands[i], sourceRectangle);
dataBuffers[i] = sourceTiles[i].getDataBuffer();
}
final TileIndex srcIndex = new TileIndex(sourceTiles[0]);
for (int y = y0; y < yMax; ++y) {
for (int x = x0; x < xMax; ++x) {
PolOpUtils.getMeanCoherencyMatrix(
x,
y,
halfWindowSizeX,
halfWindowSizeY,
srcWidth,
srcHeight,
sourceProductType,
srcIndex,
dataBuffers,
Tr,
Ti);
int clusterIdx;
synchronized (clusterCounter) {
if (mask[y][x] < -64) { // pv
clusterIdx = findClosestCluster(Tr, Ti, pvCenterList);
computeSummationOfT3(clusterIdx + 1, Tr, Ti, pvSumRe, pvSumIm);
clusterCounter[0][clusterIdx] += 1;
mask[y][x] = (byte) (-128 + clusterIdx);
} else if (mask[y][x] < 0) { // pd
clusterIdx = findClosestCluster(Tr, Ti, pdCenterList);
computeSummationOfT3(clusterIdx + 1, Tr, Ti, pdSumRe, pdSumIm);
clusterCounter[1][clusterIdx] += 1;
mask[y][x] = (byte) (-64 + clusterIdx);
} else if (mask[y][x] < 64) { // ps
clusterIdx = findClosestCluster(Tr, Ti, psCenterList);
computeSummationOfT3(clusterIdx + 1, Tr, Ti, psSumRe, psSumIm);
clusterCounter[2][clusterIdx] += 1;
mask[y][x] = (byte) clusterIdx;
} else { // mixed
java.util.List<ClusterInfo> allCenterList = new ArrayList<>();
allCenterList.addAll(pvCenterList);
allCenterList.addAll(pdCenterList);
allCenterList.addAll(psCenterList);
clusterIdx = findClosestCluster(Tr, Ti, allCenterList);
if (clusterIdx >= pvNumClusters + pdNumClusters) { // ps
clusterIdx -= pvNumClusters + pdNumClusters;
computeSummationOfT3(clusterIdx + 1, Tr, Ti, psSumRe, psSumIm);
clusterCounter[2][clusterIdx] += 1;
mask[y][x] = (byte) clusterIdx;
} else if (clusterIdx >= pvNumClusters) { // pd
clusterIdx -= pvNumClusters;
computeSummationOfT3(clusterIdx + 1, Tr, Ti, pdSumRe, pdSumIm);
clusterCounter[1][clusterIdx] += 1;
mask[y][x] = (byte) (-64 + clusterIdx);
} else { // pv
computeSummationOfT3(clusterIdx + 1, Tr, Ti, pvSumRe, pvSumIm);
clusterCounter[0][clusterIdx] += 1;
mask[y][x] = (byte) (-128 + clusterIdx);
}
}
}
}
}
}
};
threadManager.add(worker);
status.worked(1);
}
threadManager.finish();
/*
endTime = System.nanoTime();
final long duration = endTime - startTime;
System.out.println("duration = " + duration);
*/
updateClusterCenter(pvCenterList, clusterCounter[0], pvSumRe, pvSumIm);
updateClusterCenter(pdCenterList, clusterCounter[1], pdSumRe, pdSumIm);
updateClusterCenter(psCenterList, clusterCounter[2], psSumRe, psSumIm);
}
/*
System.out.println("# of clusters in Pv: " + pvNumClusters);
System.out.print("Pixels in each Pv cluster: ");
for (int i = 0; i < pvNumClusters; i++) {
System.out.print(clusterCounter[0][i] + ", ");
}
System.out.println();
System.out.println("# of clusters in Pd: " + pdNumClusters);
System.out.print("Pixels in each Pd cluster: ");
for (int i = 0; i < pdNumClusters; i++) {
System.out.print(clusterCounter[1][i] + ", ");
}
System.out.println();
System.out.println("# of clusters in Ps: " + psNumClusters);
System.out.print("Pixels in each Ps cluster: ");
for (int i = 0; i < psNumClusters; i++) {
System.out.print(clusterCounter[2][i] + ", ");
}
System.out.println();
*/
// todo the average cluster power should be used in colour selection for each cluster, not
// used now
// compute average power for each cluster
final double[] pvAvgClusterPower = new double[pvNumClusters];
final double[] pdAvgClusterPower = new double[pdNumClusters];
final double[] psAvgClusterPower = new double[psNumClusters];
int clusterIdx = -1;
for (int y = 0; y < srcHeight; y++) {
for (int x = 0; x < srcWidth; x++) {
if (mask[y][x] < -64) { // pv
clusterIdx = mask[y][x] + 128;
pvAvgClusterPower[clusterIdx] += fdd[y][x];
} else if (mask[y][x] < 0) { // pd
clusterIdx = mask[y][x] + 64;
pdAvgClusterPower[clusterIdx] += fdd[y][x];
} else { // ps
clusterIdx = mask[y][x];
psAvgClusterPower[clusterIdx] += fdd[y][x];
}
}
}
for (int c = 0; c < pvNumClusters; c++) {
pvAvgClusterPower[c] /= clusterCounter[0][c];
}
for (int c = 0; c < pdNumClusters; c++) {
pdAvgClusterPower[c] /= clusterCounter[1][c];
}
for (int c = 0; c < psNumClusters; c++) {
psAvgClusterPower[c] /= clusterCounter[2][c];
}
// map cluster index to colour index, colour index ranges for the 3 categories are given by
// surf: [0,29], vol: [30, 59] and dbl: [60,89], currently the clusters are evenly distributed
// in the
// colour range
pvColourIndexMap = new int[pvNumClusters];
pdColourIndexMap = new int[pdNumClusters];
psColourIndexMap = new int[psNumClusters];
for (int c = 0; c < pvNumClusters; c++) {
pvColourIndexMap[c] =
numInitialClusters + getColourIndex(c, pvAvgClusterPower, numInitialClusters) + 1;
}
for (int c = 0; c < pdNumClusters; c++) {
pdColourIndexMap[c] =
2 * numInitialClusters + getColourIndex(c, pdAvgClusterPower, numInitialClusters) + 1;
}
for (int c = 0; c < psNumClusters; c++) {
psColourIndexMap[c] = getColourIndex(c, psAvgClusterPower, numInitialClusters) + 1;
}
} catch (Throwable e) {
OperatorUtils.catchOperatorException(op.getId() + " computeInitialClusterCenters ", e);
} finally {
status.done();
}
}
// Is used if one Territory attacks another returns true if ownedby player has won
public boolean Attack(Territory defterritory) {
// Used Variables get initialized
int attackarmys;
int defarmys;
// Get positioned armys on this territory which is attacking and cap them on 3
attackarmys = (this.CheckArmyCount() - 1);
if (attackarmys >= 3) {
attackarmys = 3;
}
// Get positioned armys on the other territory which is defending and cap them on 2
defarmys = (defterritory.CheckArmyCount());
if (defarmys >= 2) {
defarmys = 2;
}
// If 1 or more army are attacking
if (attackarmys >= 1) {
// Create Random Generator
Random randomGenerator = new Random();
// Create Arrays for representing the dices
int[] attackeyes = new int[attackarmys];
int[] defeyes = new int[defarmys];
// Get random numbers for the attackdices
for (int i = 0; i < attackarmys; i++) {
attackeyes[i] = randomGenerator.nextInt(6) + 1;
}
// Get random numbers for the defensedices
for (int i = 0; i < defarmys; i++) {
defeyes[i] = randomGenerator.nextInt(6) + 1;
}
// Sort the Arrays by number
java.util.Arrays.sort(attackeyes);
java.util.Arrays.sort(defeyes);
// Go through the arrays starting with the highest element
for (int i = 1; i < (defarmys + 1) && i < (attackarmys + 1); i++) {
// Check if the attackdice is greater than the defensedice
if (attackeyes[attackarmys - i] > defeyes[defarmys - i]) {
System.out.println(
"Rollwin:"
+ i
+ " - Eyes:"
+ attackeyes[attackarmys - i]
+ "/"
+ defeyes[defarmys - i]);
// If 1 army of the defending territory was removed and the corresponding army was beaten
// (completely)
if (defterritory.removeArmies(1, this.ownedby)) {
// Take over the territory with the attacking armys
defterritory.enforceArmies(attackarmys - i, this.ownedby);
// And remove them by their former territory
this.removeArmies(attackarmys - i, this.ownedby);
// Return true for a successful attack
return true;
}
} else {
System.out.println(
"Rolllose:"
+ i
+ " - Eyes:"
+ attackeyes[attackarmys - i]
+ "/"
+ defeyes[defarmys - i]);
// Else remove one army of the attackers
this.removeArmies(1, this.ownedby);
}
}
}
return false;
}