Java BitmapCanvasProvider类代码示例

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
public PaymentPdfBuilder barCode(final String barCodeMessage,
                                 final float x,
                                 final float y) throws IOException {
    final float scale = 100f / BAR_CODE_DPI;
    final Code128Bean code128Bean = new Code128Bean();
    code128Bean.setCodeset(Code128Constants.CODESET_C);
    code128Bean.setMsgPosition(HumanReadablePlacement.HRP_NONE);
    code128Bean.setBarHeight(scale * BAR_CODE_HEIGHT_MM);

    final BitmapCanvasProvider canvas = new BitmapCanvasProvider(
            BAR_CODE_DPI, BufferedImage.TYPE_BYTE_BINARY, false, 0);
    code128Bean.generateBarcode(canvas, barCodeMessage);
    canvas.finish();

    final PDImageXObject pdImage = LosslessFactory.createFromImage(pdfDocument, canvas.getBufferedImage());

    try (final PDPageContentStream contentStream = new PDPageContentStream(
            pdfDocument, pdfDocument.getPage(0), PDPageContentStream.AppendMode.APPEND, true)) {
        contentStream.drawImage(pdImage, x, y, scale * pdImage.getWidth(), scale * pdImage.getHeight());
    }

    return this;
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
private boolean renderUsingBitmap(RendererContext context,
        final BarcodeGenerator bargen,
        final String msg, final int orientation) throws IOException {
    ImageAdapter imgAdapter = context.getRenderer().getImageAdapter();
    if (imgAdapter != null) {

        BitmapCanvasProvider canvas = new BitmapCanvasProvider(
                300, BufferedImage.TYPE_BYTE_BINARY, false, orientation);
        bargen.generateBarcode(canvas, msg);

        if (DEBUG) {
            System.out.println(" --> Bitmap");
        }
        imgAdapter.paintImage(canvas.getBufferedImage(),
                context,
                ((Integer)context.getProperty("xpos")).intValue(),
                ((Integer)context.getProperty("ypos")).intValue(),
                ((Integer)context.getProperty("width")).intValue(),
                ((Integer)context.getProperty("height")).intValue());
        return true;
    } else {
        //We can't paint the barcode
        return false;
    }
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
@Override
public Renderable createImage(
	JasperReportsContext jasperReportsContext,
	JRComponentElement componentElement, 
	BarcodeGenerator barcode, 
	String message
	)
{
	try
	{
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		
		int resolution = JRPropertiesUtil.getInstance(jasperReportsContext).getIntegerProperty(
				componentElement, PROPERTY_RESOLUTION, 300);
		boolean gray = JRPropertiesUtil.getInstance(jasperReportsContext).getBooleanProperty(
				componentElement, PROPERTY_GRAY, true);
		boolean antiAlias = JRPropertiesUtil.getInstance(jasperReportsContext).getBooleanProperty(
				componentElement, PROPERTY_ANTIALIAS, true);
		int imageType = gray ? BufferedImage.TYPE_BYTE_GRAY 
				: BufferedImage.TYPE_BYTE_BINARY;
		
		BitmapCanvasProvider provider = 
			new BitmapCanvasProvider(
				out, "image/x-png", resolution, imageType, antiAlias, 
				((Barcode4jComponent)componentElement.getComponent()).getOrientationValue().getValue()
				);
		barcode.generateBarcode(provider, message);
		provider.finish();
		
		byte[] imageData = out.toByteArray();
		return SimpleDataRenderer.getInstance(imageData);
	}
	catch (Exception e)
	{
		throw new JRRuntimeException(e);
	}
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
private BufferedImage createBarcode() throws IOException
{
	String data = (volume.getIsbn().equals("") ? volume.getBarcode() : volume.getIsbn().replace("-", "")) + "+" + (volume.getNumber().length() == 1 ? "0" + volume.getNumber() : volume.getNumber());
	EAN13Bean bean = new EAN13Bean();
	bean.setHeight(12d);
	bean.setModuleWidth(UnitConv.in2mm(1.0f / 100));
	bean.setFontSize(2);

	BitmapCanvasProvider provider = new BitmapCanvasProvider(100, BufferedImage.TYPE_INT_RGB, true, 0);
	bean.generateBarcode(provider, data);
	provider.finish();

	BufferedImage barcodeImage = provider.getBufferedImage();
	BufferedImage result = new BufferedImage(barcodeImage.getWidth() + 4, barcodeImage.getHeight() + 9, BufferedImage.TYPE_INT_RGB);
	Graphics2D g2d = result.createGraphics();
	g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

	g2d.setPaint(Utilities.deriveColorAlpha(BorderUtils.DEFAULT_LINE_COLOR, 255));
	g2d.fillRect(0, 0, result.getWidth(), result.getHeight());
	g2d.setPaint(Color.WHITE);
	g2d.fillRect(2, 2, result.getWidth() - 4, result.getHeight() - 4);
	g2d.drawImage(barcodeImage, 2, 5, barcodeImage.getWidth(), barcodeImage.getHeight(), null);

	g2d.dispose();

	return result;
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
@Override
public cfData execute( cfSession _session, cfArgStructData argStruct ) throws cfmRunTimeException {
	// Grab passed in arguments, and set up defaults
	String thePath  	= getNamedStringParam( argStruct, "path" , "" );
	String theType 		= getNamedStringParam( argStruct, "type" , "" );
	String theString 	= getNamedStringParam( argStruct, "string" , "" );
	int	resolution		= getNamedIntParam( argStruct, "resolution", 200 );
	
	try( OutputStream fout = new FileOutputStream(thePath) ) {
		if( theType.equals( "qr") ){
		  String qrCodeText = theString;
		  String filePath 	= thePath;
		  String fileType 	= "jpg";
		  File qrFile 			= new File(filePath);
		  createQRImage(qrFile, qrCodeText, resolution, fileType);
		} else {
			// Initialize Barcode4J things
			BarcodeUtil util = BarcodeUtil.getInstance();
	    BarcodeGenerator gen;
    
  		// Create barcode
			gen = util.createBarcodeGenerator( buildCfg(theType) );
	    BitmapCanvasProvider canvas = new BitmapCanvasProvider( fout, "image/jpeg", resolution, BufferedImage.TYPE_BYTE_BINARY, false, 0 );
	    gen.generateBarcode( canvas, theString );
	    canvas.finish();
		}
		
	} catch( Exception e) {
		throwException( _session, "An error occured when trying to generate barcode: " + e.getMessage() );
	}
	
	// If we get here, all is well and we just return a boolean true
	return cfBooleanData.getcfBooleanData(true);
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
private synchronized BufferedImage getBufferedBarcodeImage(String documentNumber, BarcodeGenerator bean){
    try {
        BitmapCanvasProvider canvas = new BitmapCanvasProvider(DPI, BufferedImage.TYPE_BYTE_BINARY,false ,0 );
        bean.generateBarcode(canvas, documentNumber);
        BufferedImage image=canvas.getBufferedImage();
        canvas.finish();
        return image;
    }
    catch(Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
public static void main(String[] args) {
    try {
        //Create the barcode bean
        Code39Bean bean = new Code39Bean();
        
        final int dpi = 150;
        
        //Configure the barcode generator
        bean.setModuleWidth(UnitConv.in2mm(1.0f / dpi)); //makes the narrow bar 
                                                         //width exactly one pixel
        bean.setWideFactor(3);
        bean.doQuietZone(false);
        
        //Open output file
        File outputFile = new File("out.jpg");
        OutputStream out = new FileOutputStream(outputFile);
        try {
            //Set up the canvas provider for monochrome JPEG output 
            BitmapCanvasProvider canvas = new BitmapCanvasProvider(
                    out, "image/jpeg", dpi, BufferedImage.TYPE_BYTE_BINARY, false, 0);
        
            //Generate the barcode
            bean.generateBarcode(canvas, "123456");
        
            //Signal end of generation
            canvas.finish();
        } finally {
            out.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
protected void readInput(PipelineContext context, ProcessorInput input, Config config, OutputStream outputStream) {

        // Read inputs
        final Document configDocument = readCacheInputAsDOM4J(context, "barcode");
		final Document instanceDocument = readInputAsDOM4J(context, "data");

        // Wraps documents for XPath API
        final DocumentInfo configDocumentInfo = new DocumentWrapper(configDocument, null, XPathCache.getGlobalConfiguration());
		final DocumentInfo instanceDocumentInfo = new DocumentWrapper(instanceDocument, null, XPathCache.getGlobalConfiguration());

		try {
            final StringBuilderWriter barcodeConfigWriter = new StringBuilderWriter();
			configDocument.write(barcodeConfigWriter);

			final DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder();
			final Configuration cfg = builder.build(new StringInputStream(Dom4jUtils.domToString(configDocument)));
			final BarcodeGenerator gen = BarcodeUtil.getInstance().createBarcodeGenerator(cfg);

            // TODO: These parameters (DPI, etc.) should be configurable
            final BitmapCanvasProvider provider = new BitmapCanvasProvider(
					outputStream, "image/x-png", 300,
					BufferedImage.TYPE_BYTE_GRAY, false);

            // Read text
            final String messageRef = XPathCache.evaluateAsString(
                    configDocumentInfo, "/barcode/@message", null, null, null,
					null, null, null, null);

			final String message = XPathCache.evaluateAsString(
                    instanceDocumentInfo, messageRef, null, null, null, null,
					null, null, null);

            // Produce barcode
            gen.generateBarcode(provider, message);
			provider.finish();

		} catch (Exception e) {
			throw new OXFException(e);
		}
	}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
private void generate() throws IOException {
       // Erstelle PDF417 Barcode
       PDF417Bean bean = new PDF417Bean();

       // Setze das Fehlerkorekturlevel  
       bean.setErrorCorrectionLevel(2);

       // Nur zwei Spalten mit Inhalt
       bean.setColumns(2);

       bean.setModuleWidth(UnitConv.in2mm(10.0f / dpi));
       bean.doQuietZone(false);

       BitmapCanvasProvider bitmapCanvasProvider = new BitmapCanvasProvider(
               dpi, BufferedImage.TYPE_BYTE_BINARY, antiAlias, orientation);

       // Erstelle den Barcode
       bean.generateBarcode(bitmapCanvasProvider, uuid);

       // Beende die Barcode Generierung
       bitmapCanvasProvider.finish();

       // Hole das BufferedImage
       BufferedImage bufferedImage = bitmapCanvasProvider.getBufferedImage();


       int width = bufferedImage.getWidth();
       int height = bufferedImage.getHeight();

       //Add padding
       int padding = 2;
       width += 2 * padding;
       height += 3 * padding;

       BufferedImage bitmap = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
       Graphics2D g2d = (Graphics2D)bitmap.getGraphics();
       g2d.setBackground(Color.white);
       g2d.setColor(Color.black);
       g2d.clearRect(0, 0, bitmap.getWidth(), bitmap.getHeight());
       

       //Place the barcode symbol
       AffineTransform symbolPlacement = new AffineTransform();
       symbolPlacement.translate(padding, padding);
       g2d.drawRenderedImage(bufferedImage, symbolPlacement);

       //Add text lines (or anything else you might want to add)

       g2d.dispose();

       //Encode bitmap as file
       String mime = "image/png";
       OutputStream out = new FileOutputStream(file);
       try {
           final BitmapEncoder encoder = BitmapEncoderRegistry.getInstance(mime);
           encoder.encode(bitmap, out, mime, dpi);
       } finally {
           out.close();
       }
       
}
 

import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider; //导入依赖的package包/类
/**
 * @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest, HttpServletResponse)
 */
protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

    try {
        String format = determineFormat(request);
        int orientation = 0;

        Configuration cfg = buildCfg(request);

        String msg = request.getParameter(BARCODE_MSG);
        if (msg == null) {
            msg = "0123456789";
        }

        BarcodeUtil util = BarcodeUtil.getInstance();
        BarcodeGenerator gen = util.createBarcodeGenerator(cfg);

        ByteArrayOutputStream bout = new ByteArrayOutputStream(4096);
        try {
            if (format.equals(MimeTypes.MIME_SVG)) {
                //Create Barcode and render it to SVG
                SVGCanvasProvider svg = new SVGCanvasProvider(false, orientation);
                gen.generateBarcode(svg, msg);
                org.w3c.dom.DocumentFragment frag = svg.getDOMFragment();

                //Serialize SVG barcode
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer trans = factory.newTransformer();
                Source src = new javax.xml.transform.dom.DOMSource(frag);
                Result res = new javax.xml.transform.stream.StreamResult(bout);
                trans.transform(src, res);
            } else if (format.equals(MimeTypes.MIME_EPS)) {
                EPSCanvasProvider eps = new EPSCanvasProvider(bout, orientation);
                gen.generateBarcode(eps, msg);
                eps.finish();
            } else {
                String resText = request.getParameter(BARCODE_IMAGE_RESOLUTION);
                int resolution = 300; //dpi
                if (resText != null) {
                    resolution = Integer.parseInt(resText);
                }
                if (resolution > 2400) {
                    throw new IllegalArgumentException(
                        "Resolutions above 2400dpi are not allowed");
                }
                if (resolution < 10) {
                    throw new IllegalArgumentException(
                        "Minimum resolution must be 10dpi");
                }
                String gray = request.getParameter(BARCODE_IMAGE_GRAYSCALE);
                BitmapCanvasProvider bitmap = ("true".equalsIgnoreCase(gray)
                    ? new BitmapCanvasProvider(
                            bout, format, resolution,
                            BufferedImage.TYPE_BYTE_GRAY, true, orientation)
                    : new BitmapCanvasProvider(
                            bout, format, resolution,
                            BufferedImage.TYPE_BYTE_BINARY, false, orientation));
                gen.generateBarcode(bitmap, msg);
                bitmap.finish();
            }
        } finally {
            bout.close();
        }
        response.setContentType(format);
        response.setContentLength(bout.size());
        response.getOutputStream().write(bout.toByteArray());
        response.getOutputStream().flush();
    } catch (Exception e) {
        log.error("Error while generating barcode", e);
        throw new ServletException(e);
    } catch (Throwable t) {
        log.error("Error while generating barcode", t);
        throw new ServletException(t);
    }
}