/** paint the canvas into a image file of given width and height */
public void writeToImage(String s, int w, int h) {
String ext;
File f;
try {
ext = s.substring(s.lastIndexOf(".") + 1);
f = new File(s);
} catch (Exception e) {
System.out.println(e);
return;
}
if (!ext.equals("jpg") && !ext.equals("png")) {
System.out.println("Cannot write to file: Illegal extension " + ext);
return;
}
boolean opq = true;
if (theOpaque != null) opq = theOpaque;
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setBackground(Color.white);
g2.setPaint(Color.black);
g2.setStroke(new BasicStroke(1));
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
doBuffer(g2, true, new Rectangle(0, 0, w, h));
try {
ImageIO.write(image, ext, f);
} catch (Exception e) {
System.out.println(e);
}
}
public void drawScaledImage(BufferedImage im, int x, int y, int w, int h) {
float scaleX = w * 1.0f / im.getWidth();
float scaleY = h * 1.0f / im.getHeight();
AffineTransform tx = new AffineTransform();
tx.scale(scaleX, scaleY);
BufferedImageOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);
drawImage(im, op, x, y);
}
public static BufferedImage cropImage(BufferedImage bi, int x, int y, int w, int h) {
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w, h);
g2.drawImage(bi, -x, -y, null); // this);
g2.dispose();
return image;
}
public static BufferedImage tileImage(BufferedImage im, int width, int height) {
GraphicsConfiguration gc =
GraphicsEnvironment.getLocalGraphicsEnvironment()
.getDefaultScreenDevice()
.getDefaultConfiguration();
int transparency = Transparency.OPAQUE; // Transparency.BITMASK;
BufferedImage compatible = gc.createCompatibleImage(width, height, transparency);
Graphics2D g = (Graphics2D) compatible.getGraphics();
g.setPaint(new TexturePaint(im, new Rectangle(0, 0, im.getWidth(), im.getHeight())));
g.fillRect(0, 0, width, height);
return compatible;
}
public static BufferedImage scaleImage(BufferedImage bi, double scale) {
int w1 = (int) (Math.round(scale * bi.getWidth()));
int h1 = (int) (Math.round(scale * bi.getHeight()));
BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w1, h1);
g2.drawImage(bi, 0, 0, w1, h1, null); // this);
g2.dispose();
return image;
}
public static BufferedImage rotateImage(BufferedImage bi) {
int w = bi.getWidth();
int h = bi.getHeight();
BufferedImage image = new BufferedImage(h, w, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white); // getBackground());
g2.fillRect(0, 0, h, w);
g2.rotate(90 * Math.PI / 180);
g2.drawImage(bi, 0, -h, w, h, null); // this);
g2.dispose();
return image;
}
/**
* Synchronize the textLayout and the shape (=frame box, by calling syncFrame) with the model When
* <code>TextLayout</code> is used, this delegates to <code>getRotation()</code> where computing
* rotation angle is concerned, and updates the AffineTransform returned by <code>
* getTextToModelTransform()</code>.
*/
protected void syncShape() {
PicText te = (PicText) element;
// textLayout = new TextLayout(te.getText().length()==0 ? " " : te.getText(),
// textFont,
// new FontRenderContext(null,false,false));
text2ModelTr.setToIdentity(); // reset
PicPoint anchor = te.getCtrlPt(TextEditable.P_ANCHOR, ptBuf);
text2ModelTr.rotate(getRotation(), anchor.x, anchor.y); // rotate along P_ANCHOR !
// the reference point of an image is the top-left one, but the refpoint of a text layout is on
// the baseline
if (image != null) {
text2ModelTr.translate(te.getLeftX(), te.getTopY());
if (te.getWidth() != 0
&& image.getWidth() != 0
&& (te.getDepth() + te.getHeight()) != 0
&& image.getHeight() != 0)
text2ModelTr.scale(
te.getWidth() / image.getWidth(),
-(te.getHeight() + te.getDepth()) / image.getHeight());
} else {
// Hack ? Just cheating a little bit ? Ou juste ruse ?
// we want here to use the dimensions of the textLayout instead of latex dimensions if
// areDimensionsComputed
// sinon on va aligner le textlayout en fonction des parametres latex, et l'Utilisateur (qui
// est bien bete) ne va rien comprendre.
double latexH = 0;
double latexD = 0;
double latexW = 0;
if (areDimensionsComputed) { // store latex dimensions, and setDimensions to textLayout ones
latexH = te.getHeight();
latexD = te.getDepth();
latexW = te.getWidth();
te.setDimensions(
textLayout.getBounds().getWidth(), textLayout.getAscent(), textLayout.getDescent());
}
text2ModelTr.translate(te.getLeftX(), te.getBaseLineY());
if (areDimensionsComputed) { // restore latex dimensions
te.setDimensions(latexW, latexH, latexD);
}
// Autre possibilite= comprimer le texte pour qu'il rentre dans la boite (evite le hack
// ci-dessus):
// text2ModelTr.scale(te.getWidth()/textLayout.getWidth(),-(te.getHeight()+te.getDepth())/textLayout.getHeight());
text2ModelTr.scale(1.0, -1.0);
}
syncFrame();
}
// 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();
}
// 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();
}
}
}