public void getSavedLocations() {
// System.out.println("inside getSavedLocations"); //CONSOLE * * * * * * * * * * * * *
loc.clear(); // clear locations. helps refresh the list when reprinting all the locations
BufferedWriter f = null; // just in case file has not been created yet
BufferedReader br = null;
try {
// attempt to open the locations file if it doesn't exist, create it
f =
new BufferedWriter(
new FileWriter("savedLocations.txt", true)); // evaluated true if file does not exist
br = new BufferedReader(new FileReader("savedLocations.txt"));
String line; // each line is one index of the list
loc.add("Saved Locations");
// loop and read a line from the file as long as we don't get null
while ((line = br.readLine()) != null)
// add the read word to the wordList
loc.add(line);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// attempt the close the file
br.close(); // close bufferedwriter
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
/**
* Save onscreen image to file - suffix must be png, jpg, or gif.
*
* @param filename the name of the file with one of the required suffixes
*/
public static void save(String filename) {
File file = new File(filename);
String suffix = filename.substring(filename.lastIndexOf('.') + 1);
// png files
if (suffix.toLowerCase().equals("png")) {
try {
ImageIO.write(onscreenImage, suffix, file);
} catch (IOException e) {
e.printStackTrace();
}
}
// need to change from ARGB to RGB for jpeg
// reference:
// http://archives.java.sun.com/cgi-bin/wa?A2=ind0404&L=java2d-interest&D=0&P=2727
else if (suffix.toLowerCase().equals("jpg")) {
WritableRaster raster = onscreenImage.getRaster();
WritableRaster newRaster;
newRaster = raster.createWritableChild(0, 0, width, height, 0, 0, new int[] {0, 1, 2});
DirectColorModel cm = (DirectColorModel) onscreenImage.getColorModel();
DirectColorModel newCM =
new DirectColorModel(
cm.getPixelSize(), cm.getRedMask(), cm.getGreenMask(), cm.getBlueMask());
BufferedImage rgbBuffer = new BufferedImage(newCM, newRaster, false, null);
try {
ImageIO.write(rgbBuffer, suffix, file);
} catch (IOException e) {
e.printStackTrace();
}
} else {
System.out.println("Invalid image file type: " + suffix);
}
}
/** The main method. */
public static void main(String[] args)
throws IOException, InterruptedException, Correlate.CorrelateException {
// First parse the command line and test for various
// settings.
if (!commandLine(args)) System.exit(-1);
// Set the tile cache up on JAI
TileCache tc = JAI.createTileCache(tileCacheSize);
JAI jai = JAI.getDefaultInstance();
jai.setTileCache(tc);
/*
* Create an input stream from the specified file name
* to be used with the file decoding operator.
*/
FileSeekableStream stream = null;
try {
stream = new FileSeekableStream(inputImageFilename);
} catch (IOException e) {
e.printStackTrace();
System.exit(0);
}
/* Create an operator to decode the image file. */
RenderedImage inputImage = JAI.create("stream", stream);
ParameterBlock pb = new ParameterBlock();
pb.addSource(inputImage);
pb.add(new Float(10.0));
pb.add(new Float(10.0));
// Perform the color conversion.
RenderedImage processedImage = JAI.create("Scale", pb, null);
JAI.create("filestore", processedImage, outputImageFilename, encoder, null);
}
private void renderInfo() {
if (sel.rsc == null) {
try {
infoView.setPage(BLANK_PAGE);
} catch (IOException e) {
e.printStackTrace();
}
return;
}
try {
infoView.setPage(sel.rsc);
} catch (IOException e) {
e.printStackTrace();
}
}
public ByteBuffer run(Retriever retriever) {
if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL)) return null;
HTTPRetriever htr = (HTTPRetriever) retriever;
if (htr.getResponseCode() == HttpURLConnection.HTTP_NO_CONTENT) {
// Mark tile as missing to avoid excessive attempts
MercatorTiledImageLayer.this.levels.markResourceAbsent(tile);
return null;
}
if (htr.getResponseCode() != HttpURLConnection.HTTP_OK) return null;
URLRetriever r = (URLRetriever) retriever;
ByteBuffer buffer = r.getBuffer();
String suffix = WWIO.makeSuffixForMimeType(htr.getContentType());
if (suffix == null) {
return null; // TODO: log error
}
String path = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
path += suffix;
final File outFile = WorldWind.getDataFileStore().newFile(path);
if (outFile == null) return null;
try {
WWIO.saveBuffer(buffer, outFile);
return buffer;
} catch (IOException e) {
e.printStackTrace(); // TODO: log error
return null;
}
}
private <T> T scaleImageUsingAffineTransformation(final BufferedImage bufferedImage, T target) {
BufferedImage destinationImage = generateDestinationImage();
Graphics2D graphics2D = destinationImage.createGraphics();
AffineTransform transformation =
AffineTransform.getScaleInstance(
((double) getQualifiedWidth() / bufferedImage.getWidth()),
((double) getQualifiedHeight() / bufferedImage.getHeight()));
graphics2D.drawRenderedImage(bufferedImage, transformation);
graphics2D.addRenderingHints(retrieveRenderingHints());
try {
if (target instanceof File) {
LOGGER.info(String.format(M_TARGET_TYPE_OF, "File"));
ImageIO.write(destinationImage, imageType.toString(), (File) target);
} else if (target instanceof ImageOutputStream) {
LOGGER.info(String.format(M_TARGET_TYPE_OF, "ImageOutputStream"));
ImageIO.write(destinationImage, imageType.toString(), (ImageOutputStream) target);
} else if (target instanceof OutputStream) {
LOGGER.info(String.format(M_TARGET_TYPE_OF, "OutputStream"));
ImageIO.write(destinationImage, imageType.toString(), (OutputStream) target);
} else {
target = null;
}
} catch (IOException e) {
e.printStackTrace();
}
return target;
}
// Constructors and whatnot
public NodeImage(String imagePath) {
try {
nodeImage = new ImageIcon(ImageIO.read(new File(imagePath)));
} catch (IOException e) {
e.printStackTrace();
}
}
public void saveFrametoPNG(String filename) {
final int frameWidth = _canvas.getWidth();
final int frameHeight = _canvas.getHeight();
final ByteBuffer pixelsRGB = Direct.newByteBuffer(frameWidth * frameHeight * 3);
_canvas.runWithContext(
new Runnable() {
public void run() {
// glPushAttrib(GL_PIXEL_MODE_BIT);
glReadBuffer(GL_BACK);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, frameWidth, frameHeight, GL_RGB, GL_UNSIGNED_BYTE, pixelsRGB);
// glPopAttrib();
}
});
int[] pixelInts = new int[frameWidth * frameHeight];
int p = frameWidth * frameHeight * 3;
int q; // Index into ByteBuffer
int i = 0; // Index into target int[]
int w3 = frameWidth * 3; // Number of bytes in each row
for (int row = 0; row < frameHeight; row++) {
p -= w3;
q = p;
for (int col = 0; col < frameWidth; col++) {
int iR = pixelsRGB.get(q++);
int iG = pixelsRGB.get(q++);
int iB = pixelsRGB.get(q++);
pixelInts[i++] =
0xFF000000 | ((iR & 0x000000FF) << 16) | ((iG & 0x000000FF) << 8) | (iB & 0x000000FF);
}
}
// Create a new BufferedImage from the pixeldata.
BufferedImage bufferedImage =
new BufferedImage(frameWidth, frameHeight, BufferedImage.TYPE_INT_ARGB);
bufferedImage.setRGB(0, 0, frameWidth, frameHeight, pixelInts, 0, frameWidth);
try {
javax.imageio.ImageIO.write(bufferedImage, "PNG", new File(filename));
} catch (IOException e) {
System.out.println("Error: ImageIO.write.");
e.printStackTrace();
}
/* End code taken from: http://www.felixgers.de/teaching/jogl/imagingProg.html */
/*
final BufferedImage image = new BufferedImage(
this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics gr = image.getGraphics();
this.printAll(gr);
gr.dispose();
try {
ImageIO.write(image, "PNG", new File(filename));
} catch (IOException e) {
System.out.println( "Error: ImageIO.write." );
e.printStackTrace();
}
*/
}
/**
* Construct a <code>DCRaw</code> object.
*
* @param fileName The full path of the raw image file.
*/
private DCRaw(String fileName) {
m_fileName = fileName;
try {
runDCRawInfo(false);
} catch (IOException e) {
e.printStackTrace();
}
}
Sidebar() {
super(BoxLayout.Y_AXIS);
try {
back =
ImageIO.read(
ClassLoader.getSystemClassLoader()
.getResource("org/madeirahs/editor/ui/help_sidebar.png"));
scaleImage();
setPreferredSize(new Dimension(back.getWidth(), back.getHeight()));
} catch (IOException e) {
e.printStackTrace();
}
}
private static MalletTexture.Meta createMeta(final String _path, final InputStream _stream) {
try (final ImageInputStream in = ImageIO.createImageInputStream(_stream)) {
final Iterator<ImageReader> readers = ImageIO.getImageReaders(in);
if (readers.hasNext()) {
final ImageReader reader = readers.next();
try {
reader.setInput(in);
// Add additional Meta information to MalletTexture as
// and when it becomes needed. It shouldn't hold too much (RGB, RGBA, Mono, endinese,
// 32, 24-bit, etc)
// data as a game-developer shouldn't need detailed information.
return new MalletTexture.Meta(_path, reader.getHeight(0), reader.getWidth(0));
} finally {
reader.dispose();
}
}
} catch (IOException ex) {
ex.printStackTrace();
}
return null;
}
protected void getDimensionsFromLogFile(BufferedReader reader, PicText text) {
if (reader == null) {
return;
}
String line = ""; // il rale si j'initialise pas ...
boolean finished = false;
while (!finished) {
try {
line = reader.readLine();
} catch (IOException ioex) {
ioex.printStackTrace();
return;
}
if (line == null) {
System.out.println("Size of text not found in log file...");
return;
}
System.out.println(line);
Matcher matcher = LogFilePattern.matcher(line);
if (line != null && matcher.find()) {
System.out.println("FOUND :" + line);
finished = true;
try {
text.setDimensions(
0.3515 * Double.parseDouble(matcher.group(1)), // height, pt->mm (1pt=0.3515 mm)
0.3515 * Double.parseDouble(matcher.group(2)), // width
0.3515 * Double.parseDouble(matcher.group(3))); // depth
areDimensionsComputed = true;
} catch (NumberFormatException e) {
System.out.println("Logfile number format problem: $line" + e.getMessage());
} catch (IndexOutOfBoundsException e) {
System.out.println("Logfile regexp problem: $line" + e.getMessage());
}
}
}
return;
}
public void run() {
final FileStream file = GlobalFileSystem.getFile(texturePath);
if (file.exists() == false) {
Logger.println("Failed to create Texture: " + texturePath, Logger.Verbosity.NORMAL);
return;
}
try {
final DesktopByteIn in = (DesktopByteIn) file.getByteInStream();
final InputStream stream = in.getInputStream();
final BufferedImage image = ImageIO.read(stream);
in.close();
synchronized (toBind) {
// We don't want to bind the BufferedImage now
// as that will take control of the OpenGL context.
toBind.add(new Tuple<String, BufferedImage>(texturePath, image));
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
// Takes a PImage and compresses it into a JPEG byte stream
// Adapted from Dan Shiffman's UDP Sender code
public byte[] compressImage(PImage img) {
// We need a buffered image to do the JPG encoding
BufferedImage bimg = new BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_RGB);
img.loadPixels();
bimg.setRGB(0, 0, img.width, img.height, img.pixels, 0, img.width);
// Need these output streams to get image as bytes for UDP communication
ByteArrayOutputStream baStream = new ByteArrayOutputStream();
BufferedOutputStream bos = new BufferedOutputStream(baStream);
// Turn the BufferedImage into a JPG and put it in the BufferedOutputStream
// Requires try/catch
try {
ImageIO.write(bimg, "jpg", bos);
} catch (IOException e) {
e.printStackTrace();
}
// Get the byte array, which we will send out via UDP!
return baStream.toByteArray();
}
private void writeToFile(File selectedFile, ImageWriterSpiFileFilter ff) {
try {
ImageOutputStream ios = ImageIO.createImageOutputStream(selectedFile);
ImageWriter iw = ff.getImageWriterSpi().createWriterInstance();
iw.setOutput(ios);
ImageWriteParam iwp = iw.getDefaultWriteParam();
if (iwp.canWriteCompressed()) {
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
// set maximum image quality
iwp.setCompressionQuality(1.f);
}
Image image = viewerPanel.getImage();
BufferedImage bufferedImage;
if (viewerPanel.getImage() instanceof BufferedImage)
bufferedImage = (BufferedImage) viewerPanel.getImage();
else {
bufferedImage =
new BufferedImage(
image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
bufferedImage.createGraphics().drawImage(image, 0, 0, null);
}
iw.write(null, new IIOImage(bufferedImage, null, null), iwp);
iw.dispose();
ios.close();
} catch (IOException ioe) {
JOptionPane.showMessageDialog(
viewerPanel,
messagesBundle.getString(
"ImageViewerPanelSaveAction." + "Error_during_image_saving_message_7"),
//$NON-NLS-1$
messagesBundle.getString("ImageViewerPanelSaveAction." + "Error_dialog_title_8"),
//$NON-NLS-1$
JOptionPane.ERROR_MESSAGE);
ioe.printStackTrace();
}
}
// Constructor connection receiving a socket number
public ClientGUI(String host, int port, int udpPort) {
super("Clash of Clans");
defaultPort = port;
defaultUDPPort = udpPort;
defaultHost = host;
// the server name and the port number
JPanel serverAndPort = new JPanel(new GridLayout(1, 5, 1, 3));
tfServer = new JTextField(host);
tfPort = new JTextField("" + port);
tfPort.setHorizontalAlignment(SwingConstants.RIGHT);
// CHAT COMPONENTS
chatStatus = new JLabel("Please login first", SwingConstants.LEFT);
chatField = new JTextField(18);
chatField.setBackground(Color.WHITE);
JPanel chatControls = new JPanel();
chatControls.add(chatStatus);
chatControls.add(chatField);
chatControls.setBounds(0, 0, 200, 50);
chatArea = new JTextArea("Welcome to the Chat room\n", 80, 80);
chatArea.setEditable(false);
JScrollPane jsp = new JScrollPane(chatArea);
jsp.setBounds(0, 50, 200, 550);
JPanel chatPanel = new JPanel(null);
chatPanel.setSize(1000, 600);
chatPanel.add(chatControls);
chatPanel.add(jsp);
// LOGIN COMPONENTS
mainLogin = new MainPanel();
mainLogin.add(new JLabel("Main Login"));
usernameField = new JTextField("user", 15);
passwordField = new JTextField("password", 15);
login = new CButton("Login");
login.addActionListener(this);
sideLogin = new SidePanel(new FlowLayout(FlowLayout.LEFT));
sideLogin.add(usernameField);
sideLogin.add(passwordField);
sideLogin.add(login);
// MAIN MENU COMPONENTS
mainMenu = new MainPanel();
mmLabel = new JLabel("Main Menu");
timer = new javax.swing.Timer(1000, this);
mainMenu.add(mmLabel);
sideMenu = new SidePanel(new FlowLayout(FlowLayout.LEFT));
cmButton = new CButton("Customize Map");
tmButton = new CButton("Troop Movement");
gsButton = new CButton("Game Start");
logout = new CButton("Logout");
cmButton.addActionListener(this);
tmButton.addActionListener(this);
gsButton.addActionListener(this);
logout.addActionListener(this);
sideMenu.add(cmButton);
// sideMenu.add(tmButton);
sideMenu.add(gsButton);
sideMenu.add(logout);
// CM COMPONENTS
mainCM = new MainPanel(new GridLayout(mapSize, mapSize));
tiles = new Tile[mapSize][mapSize];
int tileSize = mainCM.getWidth() / mapSize;
for (int i = 0; i < mapSize; i++) {
tiles[i] = new Tile[mapSize];
for (int j = 0; j < mapSize; j++) {
tiles[i][j] = new Tile(i, j);
tiles[i][j].setPreferredSize(new Dimension(tileSize, tileSize));
tiles[i][j].setSize(tileSize, tileSize);
tiles[i][j].addActionListener(this);
if ((i + j) % 2 == 0) tiles[i][j].setBackground(new Color(102, 255, 51));
else tiles[i][j].setBackground(new Color(51, 204, 51));
mainCM.add(tiles[i][j]);
}
}
sideCM = new SidePanel(new FlowLayout(FlowLayout.LEFT));
cmBack = new CButton("Main Menu");
cmBack.setSize(150, 30);
cmBack.setPreferredSize(new Dimension(150, 30));
cmBack.addActionListener(this);
sideCM.add(cmBack);
// TM COMPONENTS
mainTM = new MainPanel(null);
mapTM = new Map(600);
mapTM.setPreferredSize(new Dimension(600, 600));
mapTM.setSize(600, 600);
mapTM.setBounds(0, 0, 600, 600);
mainTM.add(mapTM);
sideTM = new SidePanel(new FlowLayout(FlowLayout.LEFT));
tmBack = new CButton("Main Menu");
tmBack.setSize(150, 30);
tmBack.setPreferredSize(new Dimension(150, 30));
tmBack.addActionListener(this);
sideTM.add(tmBack);
JRadioButton button;
ButtonGroup group;
ub = new ArrayList<JRadioButton>();
group = new ButtonGroup();
button = new JRadioButton("Barbarian");
button.addActionListener(this);
ub.add(button);
sideTM.add(button);
group.add(button);
button = new JRadioButton("Archer");
button.addActionListener(this);
ub.add(button);
sideTM.add(button);
group.add(button);
createBuildings();
bb = new ArrayList<JRadioButton>();
group = new ButtonGroup();
JRadioButton removeButton = new JRadioButton("Remove Building");
bb.add(removeButton);
sideCM.add(removeButton);
group.add(removeButton);
for (int i = 0; i < bList.size(); i++) {
button = new JRadioButton(bList.get(i).getName() + '-' + bList.get(i).getQuantity());
bb.add(button);
sideCM.add(button);
group.add(button);
}
mainPanels = new MainPanel(new CardLayout());
mainPanels.add(mainLogin, "Login");
mainPanels.add(mainMenu, "Menu");
mainPanels.add(mainCM, "CM");
mainPanels.add(mainTM, "TM");
sidePanels = new SidePanel(new CardLayout());
sidePanels.add(sideLogin, "Login");
sidePanels.add(sideMenu, "Menu");
sidePanels.add(sideCM, "CM");
sidePanels.add(sideTM, "TM");
JPanel mainPanel = new JPanel(null);
mainPanel.setSize(1000, 600);
mainPanel.add(sidePanels);
mainPanel.add(mainPanels);
mainPanel.add(chatPanel);
add(mainPanel, BorderLayout.CENTER);
try {
setIconImage(ImageIO.read(new File("images/logo.png")));
} catch (IOException exc) {
exc.printStackTrace();
}
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(1000, 600);
setVisible(true);
setResizable(false);
chatField.requestFocus();
}
// Thread's run method aimed at creating a bitmap asynchronously
public void run() {
Drawing drawing = new Drawing();
PicText rawPicText = new PicText();
String s = ((PicText) element).getText();
rawPicText.setText(s);
drawing.add(
rawPicText); // bug fix: we must add a CLONE of the PicText, otherwise it loses it former
// parent... (then pb with the view )
drawing.setNotparsedCommands(
"\\newlength{\\jpicwidth}\\settowidth{\\jpicwidth}{"
+ s
+ "}"
+ CR_LF
+ "\\newlength{\\jpicheight}\\settoheight{\\jpicheight}{"
+ s
+ "}"
+ CR_LF
+ "\\newlength{\\jpicdepth}\\settodepth{\\jpicdepth}{"
+ s
+ "}"
+ CR_LF
+ "\\typeout{JPICEDT INFO: \\the\\jpicwidth, \\the\\jpicheight, \\the\\jpicdepth }"
+ CR_LF);
RunExternalCommand.Command commandToRun = RunExternalCommand.Command.BITMAP_CREATION;
// RunExternalCommand command = new RunExternalCommand(drawing, contentType,commandToRun);
boolean isWriteTmpTeXfile = true;
String bitmapExt = "png"; // [pending] preferences
String cmdLine =
"{i}/unix/tetex/create_bitmap.sh {p} {f} "
+ bitmapExt
+ " "
+ fileDPI; // [pending] preferences
ContentType contentType = getContainer().getContentType();
RunExternalCommand.isGUI = false; // System.out, no dialog box // [pending] debug
RunExternalCommand command =
new RunExternalCommand(drawing, contentType, cmdLine, isWriteTmpTeXfile);
command
.run(); // synchronous in an async. thread => it's ok (anyway, we must way until the LaTeX
// process has completed)
if (wantToComputeLatexDimensions) {
// load size of text:
try {
File logFile = new File(command.getTmpPath(), command.getTmpFilePrefix() + ".log");
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(logFile));
} catch (FileNotFoundException fnfe) {
System.out.println("Cannot find log file! " + fnfe.getMessage());
System.out.println(logFile);
} catch (IOException ioex) {
System.out.println("Log file IO exception");
ioex.printStackTrace();
} // utile ?
System.out.println("Log file created! file=" + logFile);
getDimensionsFromLogFile(reader, (PicText) element);
syncStringLocation(); // update dimensions
syncBounds();
syncFrame();
SwingUtilities.invokeLater(
new Thread() {
public void run() {
repaint(null);
}
});
// repaint(null); // now that dimensions are available, we force a repaint() [pending]
// smart-repaint ?
} catch (Exception e) {
e.printStackTrace();
}
}
if (wantToGetBitMap) {
// load image:
try {
File bitmapFile =
new File(command.getTmpPath(), command.getTmpFilePrefix() + "." + bitmapExt);
this.image = ImageIO.read(bitmapFile);
System.out.println(
"Bitmap created! file="
+ bitmapFile
+ ", width="
+ image.getWidth()
+ "pixels, height="
+ image.getHeight()
+ "pixels");
if (image == null) return;
syncStringLocation(); // sets strx, stry, and dimensions of text
syncBounds();
// update the AffineTransform that will be applied to the bitmap before displaying on screen
PicText te = (PicText) element;
text2ModelTr.setToIdentity(); // reset
PicPoint anchor = te.getCtrlPt(TextEditable.P_ANCHOR, ptBuf);
text2ModelTr.rotate(getRotation(), anchor.x, anchor.y); // rotate along P_ANCHOR !
text2ModelTr.translate(te.getLeftX(), te.getTopY());
text2ModelTr.scale(
te.getWidth() / image.getWidth(),
-(te.getHeight() + te.getDepth()) / image.getHeight());
// [pending] should do something special to avoid dividing by 0 or setting a rescaling
// factor to 0 [non invertible matrix] (java will throw an exception)
syncFrame();
SwingUtilities.invokeLater(
new Thread() {
public void run() {
repaint(null);
}
});
// repaint(null); // now that bitmap is available, we force a repaint() [pending]
// smart-repaint ?
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void build_bricks() {
ImagePlus imp;
ImagePlus orgimp;
ImageStack stack;
FileInfo finfo;
if (lvImgTitle.isEmpty()) return;
orgimp = WindowManager.getImage(lvImgTitle.get(0));
imp = orgimp;
finfo = imp.getFileInfo();
if (finfo == null) return;
int[] dims = imp.getDimensions();
int imageW = dims[0];
int imageH = dims[1];
int nCh = dims[2];
int imageD = dims[3];
int nFrame = dims[4];
int bdepth = imp.getBitDepth();
double xspc = finfo.pixelWidth;
double yspc = finfo.pixelHeight;
double zspc = finfo.pixelDepth;
double z_aspect = Math.max(xspc, yspc) / zspc;
int orgW = imageW;
int orgH = imageH;
int orgD = imageD;
double orgxspc = xspc;
double orgyspc = yspc;
double orgzspc = zspc;
lv = lvImgTitle.size();
if (filetype == "JPEG") {
for (int l = 0; l < lv; l++) {
if (WindowManager.getImage(lvImgTitle.get(l)).getBitDepth() != 8) {
IJ.error("A SOURCE IMAGE MUST BE 8BIT GLAYSCALE");
return;
}
}
}
// calculate levels
/* int baseXY = 256;
int baseZ = 256;
if (z_aspect < 0.5) baseZ = 128;
if (z_aspect > 2.0) baseXY = 128;
if (z_aspect >= 0.5 && z_aspect < 1.0) baseZ = (int)(baseZ*z_aspect);
if (z_aspect > 1.0 && z_aspect <= 2.0) baseXY = (int)(baseXY/z_aspect);
IJ.log("Z_aspect: " + z_aspect);
IJ.log("BaseXY: " + baseXY);
IJ.log("BaseZ: " + baseZ);
*/
int baseXY = 256;
int baseZ = 128;
int dbXY = Math.max(orgW, orgH) / baseXY;
if (Math.max(orgW, orgH) % baseXY > 0) dbXY *= 2;
int dbZ = orgD / baseZ;
if (orgD % baseZ > 0) dbZ *= 2;
lv = Math.max(log2(dbXY), log2(dbZ)) + 1;
int ww = orgW;
int hh = orgH;
int dd = orgD;
for (int l = 0; l < lv; l++) {
int bwnum = ww / baseXY;
if (ww % baseXY > 0) bwnum++;
int bhnum = hh / baseXY;
if (hh % baseXY > 0) bhnum++;
int bdnum = dd / baseZ;
if (dd % baseZ > 0) bdnum++;
if (bwnum % 2 == 0) bwnum++;
if (bhnum % 2 == 0) bhnum++;
if (bdnum % 2 == 0) bdnum++;
int bw = (bwnum <= 1) ? ww : ww / bwnum + 1 + (ww % bwnum > 0 ? 1 : 0);
int bh = (bhnum <= 1) ? hh : hh / bhnum + 1 + (hh % bhnum > 0 ? 1 : 0);
int bd = (bdnum <= 1) ? dd : dd / bdnum + 1 + (dd % bdnum > 0 ? 1 : 0);
bwlist.add(bw);
bhlist.add(bh);
bdlist.add(bd);
IJ.log("LEVEL: " + l);
IJ.log(" width: " + ww);
IJ.log(" hight: " + hh);
IJ.log(" depth: " + dd);
IJ.log(" bw: " + bw);
IJ.log(" bh: " + bh);
IJ.log(" bd: " + bd);
int xyl2 = Math.max(ww, hh) / baseXY;
if (Math.max(ww, hh) % baseXY > 0) xyl2 *= 2;
if (lv - 1 - log2(xyl2) <= l) {
ww /= 2;
hh /= 2;
}
IJ.log(" xyl2: " + (lv - 1 - log2(xyl2)));
int zl2 = dd / baseZ;
if (dd % baseZ > 0) zl2 *= 2;
if (lv - 1 - log2(zl2) <= l) dd /= 2;
IJ.log(" zl2: " + (lv - 1 - log2(zl2)));
if (l < lv - 1) {
lvImgTitle.add(lvImgTitle.get(0) + "_level" + (l + 1));
IJ.selectWindow(lvImgTitle.get(0));
IJ.run(
"Scale...",
"x=- y=- z=- width="
+ ww
+ " height="
+ hh
+ " depth="
+ dd
+ " interpolation=Bicubic average process create title="
+ lvImgTitle.get(l + 1));
}
}
for (int l = 0; l < lv; l++) {
IJ.log(lvImgTitle.get(l));
}
Document doc = newXMLDocument();
Element root = doc.createElement("BRK");
root.setAttribute("version", "1.0");
root.setAttribute("nLevel", String.valueOf(lv));
root.setAttribute("nChannel", String.valueOf(nCh));
root.setAttribute("nFrame", String.valueOf(nFrame));
doc.appendChild(root);
for (int l = 0; l < lv; l++) {
IJ.showProgress(0.0);
int[] dims2 = imp.getDimensions();
IJ.log(
"W: "
+ String.valueOf(dims2[0])
+ " H: "
+ String.valueOf(dims2[1])
+ " C: "
+ String.valueOf(dims2[2])
+ " D: "
+ String.valueOf(dims2[3])
+ " T: "
+ String.valueOf(dims2[4])
+ " b: "
+ String.valueOf(bdepth));
bw = bwlist.get(l).intValue();
bh = bhlist.get(l).intValue();
bd = bdlist.get(l).intValue();
boolean force_pow2 = false;
/* if(IsPowerOf2(bw) && IsPowerOf2(bh) && IsPowerOf2(bd)) force_pow2 = true;
if(force_pow2){
//force pow2
if(Pow2(bw) > bw) bw = Pow2(bw)/2;
if(Pow2(bh) > bh) bh = Pow2(bh)/2;
if(Pow2(bd) > bd) bd = Pow2(bd)/2;
}
if(bw > imageW) bw = (Pow2(imageW) == imageW) ? imageW : Pow2(imageW)/2;
if(bh > imageH) bh = (Pow2(imageH) == imageH) ? imageH : Pow2(imageH)/2;
if(bd > imageD) bd = (Pow2(imageD) == imageD) ? imageD : Pow2(imageD)/2;
*/
if (bw > imageW) bw = imageW;
if (bh > imageH) bh = imageH;
if (bd > imageD) bd = imageD;
if (bw <= 1 || bh <= 1 || bd <= 1) break;
if (filetype == "JPEG" && (bw < 8 || bh < 8)) break;
Element lvnode = doc.createElement("Level");
lvnode.setAttribute("lv", String.valueOf(l));
lvnode.setAttribute("imageW", String.valueOf(imageW));
lvnode.setAttribute("imageH", String.valueOf(imageH));
lvnode.setAttribute("imageD", String.valueOf(imageD));
lvnode.setAttribute("xspc", String.valueOf(xspc));
lvnode.setAttribute("yspc", String.valueOf(yspc));
lvnode.setAttribute("zspc", String.valueOf(zspc));
lvnode.setAttribute("bitDepth", String.valueOf(bdepth));
root.appendChild(lvnode);
Element brksnode = doc.createElement("Bricks");
brksnode.setAttribute("brick_baseW", String.valueOf(bw));
brksnode.setAttribute("brick_baseH", String.valueOf(bh));
brksnode.setAttribute("brick_baseD", String.valueOf(bd));
lvnode.appendChild(brksnode);
ArrayList<Brick> bricks = new ArrayList<Brick>();
int mw, mh, md, mw2, mh2, md2;
double tx0, ty0, tz0, tx1, ty1, tz1;
double bx0, by0, bz0, bx1, by1, bz1;
for (int k = 0; k < imageD; k += bd) {
if (k > 0) k--;
for (int j = 0; j < imageH; j += bh) {
if (j > 0) j--;
for (int i = 0; i < imageW; i += bw) {
if (i > 0) i--;
mw = Math.min(bw, imageW - i);
mh = Math.min(bh, imageH - j);
md = Math.min(bd, imageD - k);
if (force_pow2) {
mw2 = Pow2(mw);
mh2 = Pow2(mh);
md2 = Pow2(md);
} else {
mw2 = mw;
mh2 = mh;
md2 = md;
}
if (filetype == "JPEG") {
if (mw2 < 8) mw2 = 8;
if (mh2 < 8) mh2 = 8;
}
tx0 = i == 0 ? 0.0d : ((mw2 - mw + 0.5d) / mw2);
ty0 = j == 0 ? 0.0d : ((mh2 - mh + 0.5d) / mh2);
tz0 = k == 0 ? 0.0d : ((md2 - md + 0.5d) / md2);
tx1 = 1.0d - 0.5d / mw2;
if (mw < bw) tx1 = 1.0d;
if (imageW - i == bw) tx1 = 1.0d;
ty1 = 1.0d - 0.5d / mh2;
if (mh < bh) ty1 = 1.0d;
if (imageH - j == bh) ty1 = 1.0d;
tz1 = 1.0d - 0.5d / md2;
if (md < bd) tz1 = 1.0d;
if (imageD - k == bd) tz1 = 1.0d;
bx0 = i == 0 ? 0.0d : (i + 0.5d) / (double) imageW;
by0 = j == 0 ? 0.0d : (j + 0.5d) / (double) imageH;
bz0 = k == 0 ? 0.0d : (k + 0.5d) / (double) imageD;
bx1 = Math.min((i + bw - 0.5d) / (double) imageW, 1.0d);
if (imageW - i == bw) bx1 = 1.0d;
by1 = Math.min((j + bh - 0.5d) / (double) imageH, 1.0d);
if (imageH - j == bh) by1 = 1.0d;
bz1 = Math.min((k + bd - 0.5d) / (double) imageD, 1.0d);
if (imageD - k == bd) bz1 = 1.0d;
int x, y, z;
x = i - (mw2 - mw);
y = j - (mh2 - mh);
z = k - (md2 - md);
bricks.add(
new Brick(
x, y, z, mw2, mh2, md2, 0, 0, tx0, ty0, tz0, tx1, ty1, tz1, bx0, by0, bz0, bx1,
by1, bz1));
}
}
}
Element fsnode = doc.createElement("Files");
lvnode.appendChild(fsnode);
stack = imp.getStack();
int totalbricknum = nFrame * nCh * bricks.size();
int curbricknum = 0;
for (int f = 0; f < nFrame; f++) {
for (int ch = 0; ch < nCh; ch++) {
int sizelimit = bdsizelimit * 1024 * 1024;
int bytecount = 0;
int filecount = 0;
int pd_bufsize = Math.max(sizelimit, bw * bh * bd * bdepth / 8);
byte[] packed_data = new byte[pd_bufsize];
String base_dataname =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f);
String current_dataname = base_dataname + "_data" + filecount;
Brick b_first = bricks.get(0);
if (b_first.z_ != 0) IJ.log("warning");
int st_z = b_first.z_;
int ed_z = b_first.z_ + b_first.d_;
LinkedList<ImageProcessor> iplist = new LinkedList<ImageProcessor>();
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
// ImagePlus test;
// ImageStack tsst;
// test = NewImage.createByteImage("test", imageW, imageH, imageD,
// NewImage.FILL_BLACK);
// tsst = test.getStack();
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
if (ed_z > b.z_ || st_z < b.z_ + b.d_) {
if (b.z_ > st_z) {
for (int s = 0; s < b.z_ - st_z; s++) iplist.pollFirst();
st_z = b.z_;
} else if (b.z_ < st_z) {
IJ.log("warning");
for (int s = st_z - 1; s > b.z_; s--)
iplist.addFirst(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
st_z = b.z_;
}
if (b.z_ + b.d_ > ed_z) {
for (int s = ed_z; s < b.z_ + b.d_; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
ed_z = b.z_ + b.d_;
} else if (b.z_ + b.d_ < ed_z) {
IJ.log("warning");
for (int s = 0; s < ed_z - (b.z_ + b.d_); s++) iplist.pollLast();
ed_z = b.z_ + b.d_;
}
} else {
IJ.log("warning");
iplist.clear();
st_z = b.z_;
ed_z = b.z_ + b.d_;
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
}
if (iplist.size() != b.d_) {
IJ.log("Stack Error");
return;
}
// int zz = st_z;
int bsize = 0;
byte[] bdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Iterator<ImageProcessor> ipite = iplist.iterator();
while (ipite.hasNext()) {
// ImageProcessor tsip = tsst.getProcessor(zz+1);
ImageProcessor ip = ipite.next();
ip.setRoi(b.x_, b.y_, b.w_, b.h_);
if (bdepth == 8) {
byte[] data = (byte[]) ip.crop().getPixels();
System.arraycopy(data, 0, bdata, bsize, data.length);
bsize += data.length;
} else if (bdepth == 16) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
short[] data = (short[]) ip.crop().getPixels();
for (short e : data) buffer.putShort(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
} else if (bdepth == 32) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
float[] data = (float[]) ip.crop().getPixels();
for (float e : data) buffer.putFloat(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
}
}
String filename =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f)
+ "_ID"
+ String.valueOf(i);
int offset = bytecount;
int datasize = bdata.length;
if (filetype == "RAW") {
int dummy = -1;
// do nothing
}
if (filetype == "JPEG" && bdepth == 8) {
try {
DataBufferByte db = new DataBufferByte(bdata, datasize);
Raster raster = Raster.createPackedRaster(db, b.w_, b.h_ * b.d_, 8, null);
BufferedImage img =
new BufferedImage(b.w_, b.h_ * b.d_, BufferedImage.TYPE_BYTE_GRAY);
img.setData(raster);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
String format = "jpg";
Iterator<javax.imageio.ImageWriter> iter =
ImageIO.getImageWritersByFormatName("jpeg");
javax.imageio.ImageWriter writer = iter.next();
ImageWriteParam iwp = writer.getDefaultWriteParam();
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality((float) jpeg_quality * 0.01f);
writer.setOutput(ios);
writer.write(null, new IIOImage(img, null, null), iwp);
// ImageIO.write(img, format, baos);
bdata = baos.toByteArray();
datasize = bdata.length;
} catch (IOException e) {
e.printStackTrace();
return;
}
}
if (filetype == "ZLIB") {
byte[] tmpdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Deflater compresser = new Deflater();
compresser.setInput(bdata);
compresser.setLevel(Deflater.DEFAULT_COMPRESSION);
compresser.setStrategy(Deflater.DEFAULT_STRATEGY);
compresser.finish();
datasize = compresser.deflate(tmpdata);
bdata = tmpdata;
compresser.end();
}
if (bytecount + datasize > sizelimit && bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
filecount++;
current_dataname = base_dataname + "_data" + filecount;
bytecount = 0;
offset = 0;
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
} else {
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
}
Element filenode = doc.createElement("File");
filenode.setAttribute("filename", current_dataname);
filenode.setAttribute("channel", String.valueOf(ch));
filenode.setAttribute("frame", String.valueOf(f));
filenode.setAttribute("brickID", String.valueOf(i));
filenode.setAttribute("offset", String.valueOf(offset));
filenode.setAttribute("datasize", String.valueOf(datasize));
filenode.setAttribute("filetype", String.valueOf(filetype));
fsnode.appendChild(filenode);
curbricknum++;
IJ.showProgress((double) (curbricknum) / (double) (totalbricknum));
}
if (bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
}
}
}
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
Element bricknode = doc.createElement("Brick");
bricknode.setAttribute("id", String.valueOf(i));
bricknode.setAttribute("st_x", String.valueOf(b.x_));
bricknode.setAttribute("st_y", String.valueOf(b.y_));
bricknode.setAttribute("st_z", String.valueOf(b.z_));
bricknode.setAttribute("width", String.valueOf(b.w_));
bricknode.setAttribute("height", String.valueOf(b.h_));
bricknode.setAttribute("depth", String.valueOf(b.d_));
brksnode.appendChild(bricknode);
Element tboxnode = doc.createElement("tbox");
tboxnode.setAttribute("x0", String.valueOf(b.tx0_));
tboxnode.setAttribute("y0", String.valueOf(b.ty0_));
tboxnode.setAttribute("z0", String.valueOf(b.tz0_));
tboxnode.setAttribute("x1", String.valueOf(b.tx1_));
tboxnode.setAttribute("y1", String.valueOf(b.ty1_));
tboxnode.setAttribute("z1", String.valueOf(b.tz1_));
bricknode.appendChild(tboxnode);
Element bboxnode = doc.createElement("bbox");
bboxnode.setAttribute("x0", String.valueOf(b.bx0_));
bboxnode.setAttribute("y0", String.valueOf(b.by0_));
bboxnode.setAttribute("z0", String.valueOf(b.bz0_));
bboxnode.setAttribute("x1", String.valueOf(b.bx1_));
bboxnode.setAttribute("y1", String.valueOf(b.by1_));
bboxnode.setAttribute("z1", String.valueOf(b.bz1_));
bricknode.appendChild(bboxnode);
}
if (l < lv - 1) {
imp = WindowManager.getImage(lvImgTitle.get(l + 1));
int[] newdims = imp.getDimensions();
imageW = newdims[0];
imageH = newdims[1];
imageD = newdims[3];
xspc = orgxspc * ((double) orgW / (double) imageW);
yspc = orgyspc * ((double) orgH / (double) imageH);
zspc = orgzspc * ((double) orgD / (double) imageD);
bdepth = imp.getBitDepth();
}
}
File newXMLfile = new File(directory + basename + ".vvd");
writeXML(newXMLfile, doc);
for (int l = 1; l < lv; l++) {
imp = WindowManager.getImage(lvImgTitle.get(l));
imp.changes = false;
imp.close();
}
}
public static void main(String[] args) {
// read filename and N 2 parameters
String fileName = args[0];
N = Integer.parseInt(args[1]);
// output two images, one original image at left, the other result image at right
BufferedImage imgOriginal =
new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
BufferedImage img = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
try {
File file = new File(fileName);
InputStream is = new FileInputStream(file);
long len = file.length();
byte[] bytes = new byte[(int) len];
int offset = 0;
int numRead = 0;
while (offset < bytes.length
&& (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
offset += numRead;
}
int ind = 0;
for (int y = 0; y < IMAGE_HEIGHT; y++) {
for (int x = 0; x < IMAGE_WIDTH; x++) {
// for reading .raw image to show as a rgb image
byte r = bytes[ind];
byte g = bytes[ind];
byte b = bytes[ind];
// set pixel for display original image
int pixOriginal = 0xff000000 | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
imgOriginal.setRGB(x, y, pixOriginal);
ind++;
}
}
is.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
int[] vectorSpace = calculateVectorSpace(imgOriginal);
// quantization
for (int y = 0; y < IMAGE_HEIGHT; y++) {
for (int x = 0; x < IMAGE_WIDTH; x++) {
int clusterId = vectorSpace[IMAGE_WIDTH * y + x];
img.setRGB(x, y, clusters[clusterId].getPixel());
}
}
// Use a panel and label to display the image
JPanel panel = new JPanel();
panel.add(new JLabel(new ImageIcon(imgOriginal)));
panel.add(new JLabel(new ImageIcon(img)));
JFrame frame = new JFrame("Display images");
frame.getContentPane().add(panel);
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}