Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: DitherUtil.java 1785982 2017-03-08 15:15:06Z ssteiner $ */
package org.apache.fop.util.bitmap;
import java.awt.Color;
/**
* Utility methods for dithering.
*/
public final class DitherUtil {
private DitherUtil() {
}
/** Selects a 2x2 Bayer dither matrix (5 grayscales) */
public static final int DITHER_MATRIX_2X2 = 2;
/** Selects a 4x4 Bayer dither matrix (17 grayscales) */
public static final int DITHER_MATRIX_4X4 = 4;
/** Selects a 8x8 Bayer dither matrix (65 grayscales) */
public static final int DITHER_MATRIX_8X8 = 8;
//Bayer dither matrices (4x4 and 8x8 are derived from the 2x2 matrix)
private static final int[] BAYER_D2 = new int[] {0, 2, 3, 1};
private static final int[] BAYER_D4;
private static final int[] BAYER_D8;
static {
BAYER_D4 = deriveBayerMatrix(BAYER_D2);
BAYER_D8 = deriveBayerMatrix(BAYER_D4);
}
private static int[] deriveBayerMatrix(int[] d) {
int[] dn = new int[d.length * 4];
int half = (int)Math.sqrt(d.length);
for (int part = 0; part < 4; part++) {
for (int i = 0, c = d.length; i < c; i++) {
setValueInMatrix(dn, half, part, i, d[i] * 4 + BAYER_D2[part]);
}
}
return dn;
}
private static void setValueInMatrix(int[] dn, int half, int part, int idx, int value) {
int xoff = (part & 1) * half;
int yoff = (part & 2) * half * half;
int matrixIndex = yoff + ((idx / half) * half * 2) + (idx % half) + xoff;
dn[matrixIndex] = value;
}
/**
* Returns the Bayer dither base pattern for a particular matrix size.
* @param matrix the matrix size ({@link #DITHER_MATRIX_2X2}, {@link #DITHER_MATRIX_4X4}
* or {@link #DITHER_MATRIX_8X8})
* @return the base pattern for the given size
*/
public static int[] getBayerBasePattern(int matrix) {
int[] result = new int[matrix * matrix];
switch (matrix) {
case DITHER_MATRIX_2X2:
System.arraycopy(BAYER_D2, 0, result, 0, BAYER_D2.length);
break;
case DITHER_MATRIX_4X4:
System.arraycopy(BAYER_D4, 0, result, 0, BAYER_D4.length);
break;
case DITHER_MATRIX_8X8:
System.arraycopy(BAYER_D8, 0, result, 0, BAYER_D8.length);
break;
default:
throw new IllegalArgumentException("Unsupported dither matrix: " + matrix);
}
return result;
}
/**
* Returns a byte array containing the dither pattern for the given 8-bit gray value.
* @param matrix the matrix size ({@link #DITHER_MATRIX_2X2}, {@link #DITHER_MATRIX_4X4}
* or {@link #DITHER_MATRIX_8X8})
* @param gray255 the gray value (0-255)
* @param doubleMatrix true if the 4x4 matrix shall be doubled to a 8x8
* @return the dither pattern
*/
public static byte[] getBayerDither(int matrix, int gray255, boolean doubleMatrix) {
int ditherIndex;
byte[] dither;
int[] bayer;
switch (matrix) {
case DITHER_MATRIX_4X4:
ditherIndex = gray255 * 17 / 255;
bayer = BAYER_D4;
break;
case DITHER_MATRIX_8X8:
ditherIndex = gray255 * 65 / 255;
bayer = BAYER_D8;
break;
default:
throw new IllegalArgumentException("Unsupported dither matrix: " + matrix);
}
if (doubleMatrix) {
if (matrix != DITHER_MATRIX_4X4) {
throw new IllegalArgumentException("doubleMatrix=true is only allowed for 4x4");
}
dither = new byte[bayer.length / 8 * 4];
for (int i = 0, c = bayer.length; i < c; i++) {
boolean dot = !(bayer[i] < ditherIndex - 1);
if (dot) {
int byteIdx = i / 4;
dither[byteIdx] |= 1 << (i % 4);
dither[byteIdx] |= 1 << ((i % 4) + 4);
dither[byteIdx + 4] |= 1 << (i % 4);
dither[byteIdx + 4] |= 1 << ((i % 4) + 4);
}
}
} else {
dither = new byte[bayer.length / 8];
for (int i = 0, c = bayer.length; i < c; i++) {
boolean dot = !(bayer[i] < ditherIndex - 1);
if (dot) {
int byteIdx = i / 8;
dither[byteIdx] |= 1 << (i % 8);
}
}
}
return dither;
}
/**
* Returns a byte array containing the dither pattern for the given 8-bit gray value.
* @param matrix the matrix size ({@link #DITHER_MATRIX_2X2}, {@link #DITHER_MATRIX_4X4}
* or {@link #DITHER_MATRIX_8X8})
* @param col the color
* @param doubleMatrix true if the 4x4 matrix shall be doubled to a 8x8
* @return the dither pattern
*/
public static byte[] getBayerDither(int matrix, Color col, boolean doubleMatrix) {
float black = BitmapImageUtil.convertToGray(col.getRGB()) / 256f;
return getBayerDither(matrix, Math.round(black * 256), doubleMatrix);
}
}
