Convert .PNG to ASCII/EBCDIC Hexadecimal

[Robert Romano]

Hello,

I have this identical requirement of having a .png file that needs to print on a Zebra label printer. I have attempted to use the Java and RPGLE solution posted above but when I try converting a .png file, Java throws an error "javax.imageio.IIOException: Can't create an ImageInputStream!" when calling method "main" with signature "([Ljava.lang.StringV" in class "ZPLConverter". Can someone please provide some detail. Is it the IFS filename of a .png file that is the input parm or does the IFS file need to be in a different format? Is there a specific CCSID required? Thanks in advance for any help.

[OLDMAN25]

jesus somebody call 911 my nose gonna bleed

[c0nfitty]

Did my post below help?

[c0nfitty]

Yes!
I used a bit of java to help me generate the ZPL code. The main method accepts a string array. I have the java prototyped in an ILE pgm. I send it the IFS path and it returns the ZPL code. Then I weite the zpl to a printer file that's overridden to an outq. Hope this helps.

Here's the java

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.imageio.ImageIO;
import java.lang.Exception;
import java.lang.ClassLoader;
import java.io.File;
public class ZPLConverter {
    private int blackLimit = 380;
    private int total;
    private int widthBytes;
    private boolean compressHex = false;
    private static Map<Integer, String> mapCode = new HashMap<Integer, String>();
    {
        mapCode.put(1, "G");
        mapCode.put(2, "H");
        mapCode.put(3, "I");
        mapCode.put(4, "J");
        mapCode.put(5, "K");
        mapCode.put(6, "L");
        mapCode.put(7, "M");
        mapCode.put(8, "N");
        mapCode.put(9, "O");
        mapCode.put(10, "P");
        mapCode.put(11, "Q");
        mapCode.put(12, "R");
        mapCode.put(13, "S");
        mapCode.put(14, "T");
        mapCode.put(15, "U");
        mapCode.put(16, "V");
        mapCode.put(17, "W");
        mapCode.put(18, "X");
        mapCode.put(19, "Y");
        mapCode.put(20, "g");
        mapCode.put(40, "h");
        mapCode.put(60, "i");
        mapCode.put(80, "j");
        mapCode.put(100, "k");
        mapCode.put(120, "l");
        mapCode.put(140, "m");
        mapCode.put(160, "n");
        mapCode.put(180, "o");
        mapCode.put(200, "p");
        mapCode.put(220, "q");
        mapCode.put(240, "r");
        mapCode.put(260, "s");
        mapCode.put(280, "t");
        mapCode.put(300, "u");
        mapCode.put(320, "v");
        mapCode.put(340, "w");
        mapCode.put(360, "x");
        mapCode.put(380, "y");        
        mapCode.put(400, "z");            
    }
    public String convertfromImg(BufferedImage image) throws IOException {
        String cuerpo = createBody(image);
        if(compressHex)
           cuerpo = encodeHexAscii(cuerpo);
        return headDoc() + cuerpo + footDoc();        
    }
    private String createBody(BufferedImage orginalImage) throws IOException {
        StringBuffer sb = new StringBuffer();
        Graphics2D graphics = orginalImage.createGraphics();
        graphics.drawImage(orginalImage, 0, 0, null);
        int height = orginalImage.getHeight();
        int width = orginalImage.getWidth();
        int rgb, red, green, blue, index=0;        
        char auxBinaryChar[] =  {'0', '0', '0', '0', '0', '0', '0', '0'};
        widthBytes = width/8;
        if(width%8>0){
            widthBytes= (((int)(width/8))+1);
        } else {
            widthBytes= width/8;
        }
        this.total = widthBytes*height;
        for (int h = 0; h<height; h++)
        {
            for (int w = 0; w<width; w++)
            {
                rgb = orginalImage.getRGB(w, h);
                red = (rgb >> 16 ) & 0x000000FF;
                green = (rgb >> 8 ) & 0x000000FF;
                blue = (rgb) & 0x000000FF;
                char auxChar = '1';
                int totalColor = red + green + blue;
                if(totalColor>blackLimit){
                    auxChar = '0';
                }
                auxBinaryChar[index] = auxChar;
                index++;
                if(index==8 || w==(width-1)){
                    sb.append(fourByteBinary(new String(auxBinaryChar)));
                    auxBinaryChar =  new char[]{'0', '0', '0', '0', '0', '0', '0', '0'};
                    index=0;
                }
            }
            sb.append("\n");
        }
        return sb.toString();
    }
    private String fourByteBinary(String binaryStr){
        int decimal = Integer.parseInt(binaryStr,2);
        if (decimal>15){
            return Integer.toString(decimal,16).toUpperCase();
        } else {
            return "0" + Integer.toString(decimal,16).toUpperCase();
        }
    }
    private String encodeHexAscii(String code){
        int maxlinea =  widthBytes * 2;        
        StringBuffer sbCode = new StringBuffer();
        StringBuffer sbLinea = new StringBuffer();
        String previousLine = null;
        int counter = 1;
        char aux = code.charAt(0);
        boolean firstChar = false;
        for(int i = 1; i< code.length(); i++ ){
            if(firstChar){
                aux = code.charAt(i);
                firstChar = false;
                continue;
            }
            if(code.charAt(i)=='\n'){
                if(counter>=maxlinea && aux=='0'){
                    sbLinea.append(",");
                } else     if(counter>=maxlinea && aux=='F'){
                    sbLinea.append("!");
                } else if (counter>20){
                    int multi20 = (counter/20)*20;
                    int resto20 = (counter%20);
                    sbLinea.append(mapCode.get(multi20));
                    if(resto20!=0){
                        sbLinea.append(mapCode.get(resto20) + aux);    
                    } else {
                        sbLinea.append(aux);    
                    }
                } else {
                    sbLinea.append(mapCode.get(counter) + aux);
                    if(mapCode.get(counter)==null){
                    }
                }
                counter = 1;
                firstChar = true;
                if(sbLinea.toString().equals(previousLine)){
                    sbCode.append(":");
                } else {
                    sbCode.append(sbLinea.toString());
                }                
                previousLine = sbLinea.toString();
                sbLinea.setLength(0);
                continue;
            }
            if(aux == code.charAt(i)){
                counter++;                
            } else {
                if(counter>20){
                    int multi20 = (counter/20)*20;
                    int resto20 = (counter%20);
                    sbLinea.append(mapCode.get(multi20));
                    if(resto20!=0){
                        sbLinea.append(mapCode.get(resto20) + aux);    
                    } else {
                        sbLinea.append(aux);    
                    }
                } else {
                    sbLinea.append(mapCode.get(counter) + aux);
                }
                counter = 1;
                aux = code.charAt(i);
            }            
        }
        return sbCode.toString();
    }
    private String headDoc(){
        String str = "^XA " +
                        "^FO0,0^GFA,"+ total + ","+ total + "," + widthBytes +", ";
        return str;
    }
    private String footDoc(){
        String str = "^FS"+
                        "^XZ";        
        return str;
    }
    public void setCompressHex(boolean compressHex) {
        this.compressHex = compressHex;
    }
    public void setBlacknessLimitPercentage(int percentage){
        blackLimit = ( percentage * 768 / 100);
    }
    public static void main(String[] args) throws Exception {
        BufferedImage orginalImage = ImageIO.read(new File(args[0].trim()));
        ZPLConverter zp = new ZPLConverter();
        zp.setCompressHex(true);
        zp.setBlacknessLimitPercentage(50);     
            args[1] = zp.convertfromImg(orginalImage);
    }
}

Here's the RPG

H DFTACTGRP(*NO) Thread(*Serialize)
     ************************************************
     FPRT198    O    F  132        PRINTER usropn
     ************************************************
      /COPY QSYSINC/QRPGLESRC,JNI
      *---Java-Variables--------------------------
       dcl-s j_mainParam0 object(*JAVA : 'java.lang.String' ) Dim(2);
       dcl-s airstring Object(*JAVA:'java.lang.String');
      *------EBCDIC-char-to-Java-String--------------------
       dcl-pr makestring Object(*JAVA:'java.lang.String') extproc (*JAVA:
                                      'java.lang.String':*CONSTRUCTOR );
           bytes varchar(30) const;
       end-pr;
      *-----Java-String-to-EBCDIC-char---------------------
       dcl-pr getBytes varchar(95000) extproc(*JAVA:'java.lang.String':
                                                             'getBytes');
       End-Pr;
      *----ZPLConverter-png-to-ZPL-Java-Method---------------------
         dcl-pr main  extproc(*JAVA : 'ZPLConverter' : 'main' ) Static;
           arg0 Object(*JAVA : 'java.lang.String' ) Dim(2) Options(*VARSIZE);
         end-pr;
      *----Qc3ExecuteCommand-prototype-------------------------
          dcl-pr QcmdExc extpgm;
            *n char(512) options(*varsize) const;
            *n packed(15:5) const;
          end-pr;
      *---Main-prototype---------------------------------------
          dcl-pr Mainz extpgm('ZPLCONVERT');
            *n char(150);
            *n char(10);
           // *n ind;
          end-pr;

          dcl-pi Mainz;
            img char(150);
            outq char(10);
           // prt ind;
          end-pi;

        dcl-s prt ind;
      *---Standalone-Variables------------------------------
            dcl-s cmd varchar(512);
            dcl-s len packed(15:5);
            dcl-s t char(1) inz('''');
            dcl-s buf char(132);
            dcl-s x int(10) inz(1);
            dcl-s label char(95000);
      *-----------------------------------------------------
       /Free
        cmd = 'ADDENVVAR ENVVAR(CLASSPATH) VALUE(' + t + '.:' +
              '/OPS_util/Java/jt400.jar:/OPS_util/Java' +
                                          t + ') REPLACE(*YES)';
              len = %len(%trim(cmd));
             QcmdExc(cmd:len);

             airstring = makestring(%trim(img));
              j_mainParam0(1) = airstring;
                 Clear airstring;

             airstring = makestring(' ');
              j_mainParam0(2) = airstring;
                 Clear airstring;

              main( j_mainParam0);

               label = getBytes(j_mainParam0(2));

                 len = %len(%trim(label));

                          cmd = 'OVRPRTF FILE(PRT198) '
                            +  'DEVTYPE(*SCS) '
                            +  'OUTQ(' + %trim(Outq) + ')';

                   callp QCMDEXC(cmd: %len(cmd));

                     buf = %subst(label:x:132);
                      Open PRT198;
                        Dow buf <> *Blanks;
                          except;
                            x += 132;
                            buf = %subst(label:x:132);
                        Enddo;
                      Close PRT198;
                      prt = *on;
         *inlr = *on;
           return;
       /End-Free
      *--------------------------------------------
     Oprt198    e
     o                       buf
      *--------------------------------------------

[OLDMAN25]

You ever got this working?

[c0nfitty]

I've been working on a Web Services project for my company.
After several posts on here I have had a tremendous amount of help. (Thanks to ALL)
I've got another issue...

I'm taking a Base64 encoded XML string (.PNG), decoding it and storing it to the IFS.
(See Image#1 for decoded image)

My plan is to convert this to Hexadecimal and build an internal Print File that I can send to my Zebra Printer using Scott K's PRTSTMF.

I'm currently using the CVTHC/CVTCH to convert to Hex before I build my print file.
The problem is that it's not picking up the white space... just the data.
(Image #2 is what it looks like in the IFS)

When I convert this to Hex, I'm not getting the Blank Space.. Or X'40'...or (Hex) 00
Should I use a Different Procedure than CVTHC? (Image#3 is the converted Hex.Embedded in ZPL code. )

I've been messing with the ZPL code a lot because I'm unfamiliar with it, but when I get it to print it's just a line of dots...

I'll p[ost some code here in a bit.