ak/rxing
1
0
Fork 0
mirror of https://github.com/starovoid/rxing.git synced 2026-07-26 04:12:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

steady working on qrcode encoder

Browse Source
This commit is contained in:
Henry Schimke
2022-10-02 17:34:53 -05:00
parent 02288dcfc3
commit bbf0b920bf
8 changed files with 1062 additions and 871 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/common/mod.rs
View File

@@ -2873,7 +2873,7 @@ impl ECIEncoderSet {
pub fn new( pub fn new(
stringToEncode: &str, stringToEncode: &str,
priorityCharset: &'static dyn encoding::Encoding, priorityCharset: &'static dyn encoding::Encoding,
fnc1: u16, fnc1: i16,
) -> Self { ) -> Self {
// List of encoders that potentially encode characters not in ISO-8859-1 in one byte. // List of encoders that potentially encode characters not in ISO-8859-1 in one byte.
let mut ENCODERS = Vec::new(); let mut ENCODERS = Vec::new();
@@ -3028,7 +3028,7 @@ impl ECIEncoderSet {
return self.priorityEncoderIndex; return self.priorityEncoderIndex;
} }
pub fn canEncode(&self, c: u16, encoderIndex: usize) -> bool { pub fn canEncode(&self, c: i16, encoderIndex: usize) -> bool {
assert!(encoderIndex < self.len()); assert!(encoderIndex < self.len());
let encoder = self.encoders[encoderIndex]; let encoder = self.encoders[encoderIndex];
let enc_data = encoder.encode(&c.to_string(), encoding::EncoderTrap::Strict); let enc_data = encoder.encode(&c.to_string(), encoding::EncoderTrap::Strict);
@@ -3085,7 +3085,7 @@ static COST_PER_ECI: usize = 3;
*/ */
pub struct MinimalECIInput { pub struct MinimalECIInput {
bytes: Vec<u16>, bytes: Vec<u16>,
fnc1: u16, fnc1: i16,
} }
impl ECIInput for MinimalECIInput { impl ECIInput for MinimalECIInput {
@@ -3244,7 +3244,7 @@ impl MinimalECIInput {
* @param fnc1 denotes the character in the input that represents the FNC1 character or -1 if this is not GS1 * @param fnc1 denotes the character in the input that represents the FNC1 character or -1 if this is not GS1
* input. * input.
*/ */
pub fn new(stringToEncode: &str, priorityCharset: &'static dyn Encoding, fnc1: u16) -> Self { pub fn new(stringToEncode: &str, priorityCharset: &'static dyn Encoding, fnc1: i16) -> Self {
let encoderSet = ECIEncoderSet::new(stringToEncode, priorityCharset, fnc1); let encoderSet = ECIEncoderSet::new(stringToEncode, priorityCharset, fnc1);
let bytes = if encoderSet.len() == 1 { let bytes = if encoderSet.len() == 1 {
//optimization for the case when all can be encoded without ECI in ISO-8859-1 //optimization for the case when all can be encoded without ECI in ISO-8859-1
@@ -3252,7 +3252,7 @@ impl MinimalECIInput {
for i in 0..stringToEncode.len() { for i in 0..stringToEncode.len() {
// for (int i = 0; i < bytes.length; i++) { // for (int i = 0; i < bytes.length; i++) {
let c = stringToEncode.chars().nth(i).unwrap(); let c = stringToEncode.chars().nth(i).unwrap();
bytes_hld[i] = if c as u16 == fnc1 { 1000 } else { c as u16 }; bytes_hld[i] = if c as i16 == fnc1 { 1000 } else { c as u16 };
} }
bytes_hld bytes_hld
} else { } else {
@@ -3265,7 +3265,7 @@ impl MinimalECIInput {
} }
} }
pub fn getFNC1Character(&self) -> u16 { pub fn getFNC1Character(&self) -> i16 {
self.fnc1 self.fnc1
} }
@@ -3305,14 +3305,14 @@ impl MinimalECIInput {
edges: &mut Vec<Vec<Option<Rc<InputEdge>>>>, edges: &mut Vec<Vec<Option<Rc<InputEdge>>>>,
from: usize, from: usize,
previous: Option<Rc<InputEdge>>, previous: Option<Rc<InputEdge>>,
fnc1: u16, fnc1: i16,
) { ) {
let ch = stringToEncode.chars().nth(from).unwrap() as u16; let ch = stringToEncode.chars().nth(from).unwrap() as i16;
let mut start = 0; let mut start = 0;
let mut end = encoderSet.len(); let mut end = encoderSet.len();
if encoderSet.getPriorityEncoderIndex() >= 0 if encoderSet.getPriorityEncoderIndex() >= 0
&& (ch as u16 == fnc1 || encoderSet.canEncode(ch, encoderSet.getPriorityEncoderIndex())) && (ch as i16 == fnc1 || encoderSet.canEncode(ch, encoderSet.getPriorityEncoderIndex()))
{ {
start = encoderSet.getPriorityEncoderIndex(); start = encoderSet.getPriorityEncoderIndex();
end = start + 1; end = start + 1;
@@ -3320,7 +3320,7 @@ impl MinimalECIInput {
for i in start..end { for i in start..end {
// for (int i = start; i < end; i++) { // for (int i = start; i < end; i++) {
if ch as u16 == fnc1 || encoderSet.canEncode(ch, i) { if ch as i16 == fnc1 || encoderSet.canEncode(ch, i) {
Self::addEdge( Self::addEdge(
edges, edges,
from + 1, from + 1,
@@ -3333,7 +3333,7 @@ impl MinimalECIInput {
pub fn encodeMinimally( pub fn encodeMinimally(
stringToEncode: &str, stringToEncode: &str,
encoderSet: &ECIEncoderSet, encoderSet: &ECIEncoderSet,
fnc1: u16, fnc1: i16,
) -> Vec<u16> { ) -> Vec<u16> {
let inputLength = stringToEncode.len(); let inputLength = stringToEncode.len();
@@ -3413,18 +3413,18 @@ impl MinimalECIInput {
} }
struct InputEdge { struct InputEdge {
c: u16, c: i16,
encoderIndex: usize, //the encoding of this edge encoderIndex: usize, //the encoding of this edge
previous: Option<Rc<InputEdge>>, previous: Option<Rc<InputEdge>>,
cachedTotalSize: usize, cachedTotalSize: usize,
} }
impl InputEdge { impl InputEdge {
pub fn new( pub fn new(
c: u16, c: i16,
encoderSet: &ECIEncoderSet, encoderSet: &ECIEncoderSet,
encoderIndex: usize, encoderIndex: usize,
previous: Option<Rc<InputEdge>>, previous: Option<Rc<InputEdge>>,
fnc1: u16, fnc1: i16,
) -> Self { ) -> Self {
let mut size = if c == 1000 { let mut size = if c == 1000 {
1 1
@@ -3440,7 +3440,7 @@ impl InputEdge {
size += prev.cachedTotalSize; size += prev.cachedTotalSize;
Self { Self {
c: if c as u16 == fnc1 { 1000 } else { c as u16 }, c: if c as i16 == fnc1 { 1000 } else { c as i16 },
encoderIndex, encoderIndex,
previous: Some(prev.clone()), previous: Some(prev.clone()),
cachedTotalSize: size, cachedTotalSize: size,
@@ -3452,7 +3452,7 @@ impl InputEdge {
} }
Self { Self {
c: if c as u16 == fnc1 { 1000 } else { c as u16 }, c: if c as i16 == fnc1 { 1000 } else { c as i16 },
encoderIndex, encoderIndex,
previous: None, previous: None,
cachedTotalSize: size, cachedTotalSize: size,

6
src/lib.rs
View File

@@ -25,6 +25,12 @@ mod PlanarYUVLuminanceSourceTestCase;
#[cfg(test)] #[cfg(test)]
mod RGBLuminanceSourceTestCase; mod RGBLuminanceSourceTestCase;
pub type EncodingHintDictionary = HashMap<EncodeHintType,EncodeHintValue>;
pub type DecodingHintDictionary= HashMap<DecodeHintType,DecodeHintValue>;
pub type MetadataDictionary = HashMap<RXingResultMetadataType,RXingResultMetadataValue>;
/* /*
* Copyright 2007 ZXing authors * Copyright 2007 ZXing authors
* *

2
src/qrcode/decoder/mode.rs
View File

@@ -24,7 +24,7 @@ use super::Version;
* *
* @author Sean Owen * @author Sean Owen
*/ */
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum Mode { pub enum Mode {
TERMINATOR, //(new int[]{0, 0, 0}, 0x00), // Not really a mode... TERMINATOR, //(new int[]{0, 0, 0}, 0x00), // Not really a mode...
NUMERIC, //(new int[]{10, 12, 14}, 0x01), NUMERIC, //(new int[]{10, 12, 14}, 0x01),

2
src/qrcode/decoder/version.rs
View File

@@ -22,6 +22,8 @@ use super::{ErrorCorrectionLevel, FormatInformation};
use lazy_static::lazy_static; use lazy_static::lazy_static;
pub type VersionRef = &'static Version;
lazy_static! { lazy_static! {
static ref VERSIONS: Vec<Version> = Version::buildVersions(); static ref VERSIONS: Vec<Version> = Version::buildVersions();
} }

667
src/qrcode/encoder/MinimalEncoder.java
View File

@@ -1,667 +0,0 @@
/*
* Copyright 2021 ZXing authors
*
* Licensed 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.
*/
package com.google.zxing.qrcode.encoder;
import com.google.zxing.qrcode.decoder.Mode;
import com.google.zxing.qrcode.decoder.Version;
import com.google.zxing.common.BitArray;
import com.google.zxing.common.ECIEncoderSet;
import com.google.zxing.WriterException;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
/**
* Encoder that encodes minimally
*
* Algorithm:
*
* The eleventh commandment was "Thou Shalt Compute" or "Thou Shalt Not Compute" - I forget which (Alan Perilis).
*
* This implementation computes. As an alternative, the QR-Code specification suggests heuristics like this one:
*
* If initial input data is in the exclusive subset of the Alphanumeric character set AND if there are less than
* [6,7,8] characters followed by data from the remainder of the 8-bit byte character set, THEN select the 8-
* bit byte mode ELSE select Alphanumeric mode;
*
* This is probably right for 99.99% of cases but there is at least this one counter example: The string "AAAAAAa"
* encodes 2 bits smaller as ALPHANUMERIC(AAAAAA), BYTE(a) than by encoding it as BYTE(AAAAAAa).
* Perhaps that is the only counter example but without having proof, it remains unclear.
*
* ECI switching:
*
* In multi language content the algorithm selects the most compact representation using ECI modes.
* For example the most compact representation of the string "\u0150\u015C" (O-double-acute, S-circumflex) is
* ECI(UTF-8), BYTE(\u0150\u015C) while prepending one or more times the same leading character as in
* "\u0150\u0150\u015C", the most compact representation uses two ECIs so that the string is encoded as
* ECI(ISO-8859-2), BYTE(\u0150\u0150), ECI(ISO-8859-3), BYTE(\u015C).
*
* @author Alex Geller
*/
final class MinimalEncoder {
private enum VersionSize {
SMALL("version 1-9"),
MEDIUM("version 10-26"),
LARGE("version 27-40");
private final String description;
VersionSize(String description) {
this.description = description;
}
public String toString() {
return description;
}
}
private final String stringToEncode;
private final boolean isGS1;
private final ECIEncoderSet encoders;
private final ErrorCorrectionLevel ecLevel;
/**
* Creates a MinimalEncoder
*
* @param stringToEncode The string to encode
* @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
* chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
* charset to encode any character in the input that can be encoded by it if the charset is among the
* supported charsets.
* @param isGS1 {@code true} if a FNC1 is to be prepended; {@code false} otherwise
* @param ecLevel The error correction level.
* @see RXingResultList#getVersion
*/
MinimalEncoder(String stringToEncode, Charset priorityCharset, boolean isGS1, ErrorCorrectionLevel ecLevel) {
this.stringToEncode = stringToEncode;
this.isGS1 = isGS1;
this.encoders = new ECIEncoderSet(stringToEncode, priorityCharset, -1);
this.ecLevel = ecLevel;
}
/**
* Encodes the string minimally
*
* @param stringToEncode The string to encode
* @param version The preferred {@link Version}. A minimal version is computed (see
* {@link RXingResultList#getVersion method} when the value of the argument is null
* @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
* chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
* charset to encode any character in the input that can be encoded by it if the charset is among the
* supported charsets.
* @param isGS1 {@code true} if a FNC1 is to be prepended; {@code false} otherwise
* @param ecLevel The error correction level.
* @return An instance of {@code RXingResultList} representing the minimal solution.
* @see RXingResultList#getBits
* @see RXingResultList#getVersion
* @see RXingResultList#getSize
*/
static RXingResultList encode(String stringToEncode, Version version, Charset priorityCharset, boolean isGS1,
ErrorCorrectionLevel ecLevel) throws WriterException {
return new MinimalEncoder(stringToEncode, priorityCharset, isGS1, ecLevel).encode(version);
}
RXingResultList encode(Version version) throws WriterException {
if (version == null) { // compute minimal encoding trying the three version sizes.
Version[] versions = { getVersion(VersionSize.SMALL),
getVersion(VersionSize.MEDIUM),
getVersion(VersionSize.LARGE) };
RXingResultList[] results = { encodeSpecificVersion(versions[0]),
encodeSpecificVersion(versions[1]),
encodeSpecificVersion(versions[2]) };
int smallestSize = Integer.MAX_VALUE;
int smallestRXingResult = -1;
for (int i = 0; i < 3; i++) {
int size = results[i].getSize();
if (Encoder.willFit(size, versions[i], ecLevel) && size < smallestSize) {
smallestSize = size;
smallestRXingResult = i;
}
}
if (smallestRXingResult < 0) {
throw new WriterException("Data too big for any version");
}
return results[smallestRXingResult];
} else { // compute minimal encoding for a given version
RXingResultList result = encodeSpecificVersion(version);
if (!Encoder.willFit(result.getSize(), getVersion(getVersionSize(result.getVersion())), ecLevel)) {
throw new WriterException("Data too big for version" + version);
}
return result;
}
}
static VersionSize getVersionSize(Version version) {
return version.getVersionNumber() <= 9 ? VersionSize.SMALL : version.getVersionNumber() <= 26 ?
VersionSize.MEDIUM : VersionSize.LARGE;
}
static Version getVersion(VersionSize versionSize) {
switch (versionSize) {
case SMALL:
return Version.getVersionForNumber(9);
case MEDIUM:
return Version.getVersionForNumber(26);
case LARGE:
default:
return Version.getVersionForNumber(40);
}
}
static boolean isNumeric(char c) {
return c >= '0' && c <= '9';
}
static boolean isDoubleByteKanji(char c) {
return Encoder.isOnlyDoubleByteKanji(String.valueOf(c));
}
static boolean isAlphanumeric(char c) {
return Encoder.getAlphanumericCode(c) != -1;
}
boolean canEncode(Mode mode, char c) {
switch (mode) {
case KANJI: return isDoubleByteKanji(c);
case ALPHANUMERIC: return isAlphanumeric(c);
case NUMERIC: return isNumeric(c);
case BYTE: return true; // any character can be encoded as byte(s). Up to the caller to manage splitting into
// multiple bytes when String.getBytes(Charset) return more than one byte.
default:
return false;
}
}
static int getCompactedOrdinal(Mode mode) {
if (mode == null) {
return 0;
}
switch (mode) {
case KANJI:
return 0;
case ALPHANUMERIC:
return 1;
case NUMERIC:
return 2;
case BYTE:
return 3;
default:
throw new IllegalStateException("Illegal mode " + mode);
}
}
void addEdge(Edge[][][] edges, int position, Edge edge) {
int vertexIndex = position + edge.characterLength;
Edge[] modeEdges = edges[vertexIndex][edge.charsetEncoderIndex];
int modeOrdinal = getCompactedOrdinal(edge.mode);
if (modeEdges[modeOrdinal] == null || modeEdges[modeOrdinal].cachedTotalSize > edge.cachedTotalSize) {
modeEdges[modeOrdinal] = edge;
}
}
void addEdges(Version version, Edge[][][] edges, int from, Edge previous) {
int start = 0;
int end = encoders.length();
int priorityEncoderIndex = encoders.getPriorityEncoderIndex();
if (priorityEncoderIndex >= 0 && encoders.canEncode(stringToEncode.charAt(from),priorityEncoderIndex)) {
start = priorityEncoderIndex;
end = priorityEncoderIndex + 1;
}
for (int i = start; i < end; i++) {
if (encoders.canEncode(stringToEncode.charAt(from), i)) {
addEdge(edges, from, new Edge(Mode.BYTE, from, i, 1, previous, version));
}
}
if (canEncode(Mode.KANJI, stringToEncode.charAt(from))) {
addEdge(edges, from, new Edge(Mode.KANJI, from, 0, 1, previous, version));
}
int inputLength = stringToEncode.length();
if (canEncode(Mode.ALPHANUMERIC, stringToEncode.charAt(from))) {
addEdge(edges, from, new Edge(Mode.ALPHANUMERIC, from, 0, from + 1 >= inputLength ||
!canEncode(Mode.ALPHANUMERIC, stringToEncode.charAt(from + 1)) ? 1 : 2, previous, version));
}
if (canEncode(Mode.NUMERIC, stringToEncode.charAt(from))) {
addEdge(edges, from, new Edge(Mode.NUMERIC, from, 0, from + 1 >= inputLength ||
!canEncode(Mode.NUMERIC, stringToEncode.charAt(from + 1)) ? 1 : from + 2 >= inputLength ||
!canEncode(Mode.NUMERIC, stringToEncode.charAt(from + 2)) ? 2 : 3, previous, version));
}
}
RXingResultList encodeSpecificVersion(Version version) throws WriterException {
@SuppressWarnings("checkstyle:lineLength")
/* A vertex represents a tuple of a position in the input, a mode and a character encoding where position 0
* denotes the position left of the first character, 1 the position left of the second character and so on.
* Likewise the end vertices are located after the last character at position stringToEncode.length().
*
* An edge leading to such a vertex encodes one or more of the characters left of the position that the vertex
* represents and encodes it in the same encoding and mode as the vertex on which the edge ends. In other words,
* all edges leading to a particular vertex encode the same characters in the same mode with the same character
* encoding. They differ only by their source vertices who are all located at i+1 minus the number of encoded
* characters.
*
* The edges leading to a vertex are stored in such a way that there is a fast way to enumerate the edges ending
* on a particular vertex.
*
* The algorithm processes the vertices in order of their position thereby performing the following:
*
* For every vertex at position i the algorithm enumerates the edges ending on the vertex and removes all but the
* shortest from that list.
* Then it processes the vertices for the position i+1. If i+1 == stringToEncode.length() then the algorithm ends
* and chooses the the edge with the smallest size from any of the edges leading to vertices at this position.
* Otherwise the algorithm computes all possible outgoing edges for the vertices at the position i+1
*
* Examples:
* The process is illustrated by showing the graph (edges) after each iteration from left to right over the input:
* An edge is drawn as follows "(" + fromVertex + ") -- " + encodingMode + "(" + encodedInput + ") (" +
* accumulatedSize + ") --> (" + toVertex + ")"
*
* Example 1 encoding the string "ABCDE":
* Note: This example assumes that alphanumeric encoding is only possible in multiples of two characters so that
* the example is both short and showing the principle. In reality this restriction does not exist.
*
* Initial situation
* (initial) -- BYTE(A) (20) --> (1_BYTE)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 1
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 2
* (initial) -- BYTE(A) (20) --> (1_BYTE)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- BYTE(C) (44) --> (3_BYTE)
* (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 3
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- BYTE(D) (64) --> (4_BYTE)
* (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
* (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 4
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE) -- BYTE(D) (44) --> (4_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC) -- BYTE(E) (55) --> (5_BYTE)
*
* Situation after adding edges to vertices at position 5
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE) -- BYTE(D) (44) --> (4_BYTE) -- BYTE(E) (52) --> (5_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Encoding as BYTE(ABCDE) has the smallest size of 52 and is hence chosen. The encodation ALPHANUMERIC(ABCD),
* BYTE(E) is longer with a size of 55.
*
* Example 2 encoding the string "XXYY" where X denotes a character unique to character set ISO-8859-2 and Y a
* character unique to ISO-8859-3. Both characters encode as double byte in UTF-8:
*
* Initial situation
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 1
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2)
* (1_BYTE_ISO-8859-2) -- BYTE(X) (72) --> (2_BYTE_UTF-8)
* (1_BYTE_ISO-8859-2) -- BYTE(X) (72) --> (2_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 2
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (80) --> (3_BYTE_UTF-8)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (80) --> (3_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 3
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (80) --> (4_BYTE_ISO-8859-3)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (112) --> (4_BYTE_UTF-8)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (112) --> (4_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8) -- BYTE(Y) (72) --> (3_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE) -- BYTE(Y) (72) --> (3_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 4
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3) -- BYTE(Y) (80) --> (4_BYTE_ISO-8859-3)
* (3_BYTE_UTF-8) -- BYTE(Y) (88) --> (4_BYTE_UTF-8)
* (3_BYTE_UTF-16BE) -- BYTE(Y) (88) --> (4_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8) -- BYTE(Y) (72) --> (3_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE) -- BYTE(Y) (72) --> (3_BYTE_UTF-16BE)
*
* Encoding as ECI(ISO-8859-2),BYTE(XX),ECI(ISO-8859-3),BYTE(YY) has the smallest size of 80 and is hence chosen.
* The encodation ECI(UTF-8),BYTE(XXYY) is longer with a size of 88.
*/
int inputLength = stringToEncode.length();
// Array that represents vertices. There is a vertex for every character, encoding and mode. The vertex contains
// a list of all edges that lead to it that have the same encoding and mode.
// The lists are created lazily
// The last dimension in the array below encodes the 4 modes KANJI, ALPHANUMERIC, NUMERIC and BYTE via the
// function getCompactedOrdinal(Mode)
Edge[][][] edges = new Edge[inputLength + 1][encoders.length()][4];
addEdges(version, edges, 0, null);
for (int i = 1; i <= inputLength; i++) {
for (int j = 0; j < encoders.length(); j++) {
for (int k = 0; k < 4; k++) {
if (edges[i][j][k] != null && i < inputLength) {
addEdges(version, edges, i, edges[i][j][k]);
}
}
}
}
int minimalJ = -1;
int minimalK = -1;
int minimalSize = Integer.MAX_VALUE;
for (int j = 0; j < encoders.length(); j++) {
for (int k = 0; k < 4; k++) {
if (edges[inputLength][j][k] != null) {
Edge edge = edges[inputLength][j][k];
if (edge.cachedTotalSize < minimalSize) {
minimalSize = edge.cachedTotalSize;
minimalJ = j;
minimalK = k;
}
}
}
}
if (minimalJ < 0) {
throw new WriterException("Internal error: failed to encode \"" + stringToEncode + "\"");
}
return new RXingResultList(version, edges[inputLength][minimalJ][minimalK]);
}
private final class Edge {
private final Mode mode;
private final int fromPosition;
private final int charsetEncoderIndex;
private final int characterLength;
private final Edge previous;
private final int cachedTotalSize;
private Edge(Mode mode, int fromPosition, int charsetEncoderIndex, int characterLength, Edge previous,
Version version) {
this.mode = mode;
this.fromPosition = fromPosition;
this.charsetEncoderIndex = mode == Mode.BYTE || previous == null ? charsetEncoderIndex :
previous.charsetEncoderIndex; // inherit the encoding if not of type BYTE
this.characterLength = characterLength;
this.previous = previous;
int size = previous != null ? previous.cachedTotalSize : 0;
boolean needECI = mode == Mode.BYTE &&
(previous == null && this.charsetEncoderIndex != 0) || // at the beginning and charset is not ISO-8859-1
(previous != null && this.charsetEncoderIndex != previous.charsetEncoderIndex);
if (previous == null || mode != previous.mode || needECI) {
size += 4 + mode.getCharacterCountBits(version);
}
switch (mode) {
case KANJI:
size += 13;
break;
case ALPHANUMERIC:
size += characterLength == 1 ? 6 : 11;
break;
case NUMERIC:
size += characterLength == 1 ? 4 : characterLength == 2 ? 7 : 10;
break;
case BYTE:
size += 8 * encoders.encode(stringToEncode.substring(fromPosition, fromPosition + characterLength),
charsetEncoderIndex).length;
if (needECI) {
size += 4 + 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
}
break;
}
cachedTotalSize = size;
}
}
final class RXingResultList {
private final List<RXingResultList.RXingResultNode> list = new ArrayList<>();
private final Version version;
RXingResultList(Version version, Edge solution) {
int length = 0;
Edge current = solution;
boolean containsECI = false;
while (current != null) {
length += current.characterLength;
Edge previous = current.previous;
boolean needECI = current.mode == Mode.BYTE &&
(previous == null && current.charsetEncoderIndex != 0) || // at the beginning and charset is not ISO-8859-1
(previous != null && current.charsetEncoderIndex != previous.charsetEncoderIndex);
if (needECI) {
containsECI = true;
}
if (previous == null || previous.mode != current.mode || needECI) {
list.add(0, new RXingResultNode(current.mode, current.fromPosition, current.charsetEncoderIndex, length));
length = 0;
}
if (needECI) {
list.add(0, new RXingResultNode(Mode.ECI, current.fromPosition, current.charsetEncoderIndex, 0));
}
current = previous;
}
// prepend FNC1 if needed. If the bits contain an ECI then the FNC1 must be preceeded by an ECI.
// If there is no ECI at the beginning then we put an ECI to the default charset (ISO-8859-1)
if (isGS1) {
RXingResultNode first = list.get(0);
if (first != null && first.mode != Mode.ECI && containsECI) {
// prepend a default character set ECI
list.add(0, new RXingResultNode(Mode.ECI, 0, 0, 0));
}
first = list.get(0);
// prepend or insert a FNC1_FIRST_POSITION after the ECI (if any)
list.add(first.mode != Mode.ECI ? 0 : 1, new RXingResultNode(Mode.FNC1_FIRST_POSITION, 0, 0, 0));
}
// set version to smallest version into which the bits fit.
int versionNumber = version.getVersionNumber();
int lowerLimit;
int upperLimit;
switch (getVersionSize(version)) {
case SMALL:
lowerLimit = 1;
upperLimit = 9;
break;
case MEDIUM:
lowerLimit = 10;
upperLimit = 26;
break;
case LARGE:
default:
lowerLimit = 27;
upperLimit = 40;
break;
}
int size = getSize(version);
// increase version if needed
while (versionNumber < upperLimit && !Encoder.willFit(size, Version.getVersionForNumber(versionNumber),
ecLevel)) {
versionNumber++;
}
// shrink version if possible
while (versionNumber > lowerLimit && Encoder.willFit(size, Version.getVersionForNumber(versionNumber - 1),
ecLevel)) {
versionNumber--;
}
this.version = Version.getVersionForNumber(versionNumber);
}
/**
* returns the size in bits
*/
int getSize() {
return getSize(version);
}
private int getSize(Version version) {
int result = 0;
for (RXingResultNode resultNode : list) {
result += resultNode.getSize(version);
}
return result;
}
/**
* appends the bits
*/
void getBits(BitArray bits) throws WriterException {
for (RXingResultNode resultNode : list) {
resultNode.getBits(bits);
}
}
Version getVersion() {
return version;
}
public String toString() {
StringBuilder result = new StringBuilder();
RXingResultNode previous = null;
for (RXingResultNode current : list) {
if (previous != null) {
result.append(",");
}
result.append(current.toString());
previous = current;
}
return result.toString();
}
final class RXingResultNode {
private final Mode mode;
private final int fromPosition;
private final int charsetEncoderIndex;
private final int characterLength;
RXingResultNode(Mode mode, int fromPosition, int charsetEncoderIndex, int characterLength) {
this.mode = mode;
this.fromPosition = fromPosition;
this.charsetEncoderIndex = charsetEncoderIndex;
this.characterLength = characterLength;
}
/**
* returns the size in bits
*/
private int getSize(Version version) {
int size = 4 + mode.getCharacterCountBits(version);
switch (mode) {
case KANJI:
size += 13 * characterLength;
break;
case ALPHANUMERIC:
size += (characterLength / 2) * 11;
size += (characterLength % 2) == 1 ? 6 : 0;
break;
case NUMERIC:
size += (characterLength / 3) * 10;
int rest = characterLength % 3;
size += rest == 1 ? 4 : rest == 2 ? 7 : 0;
break;
case BYTE:
size += 8 * getCharacterCountIndicator();
break;
case ECI:
size += 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
}
return size;
}
/**
* returns the length in characters according to the specification (differs from getCharacterLength() in BYTE mode
* for multi byte encoded characters)
*/
private int getCharacterCountIndicator() {
return mode == Mode.BYTE ?
encoders.encode(stringToEncode.substring(fromPosition, fromPosition + characterLength),
charsetEncoderIndex).length : characterLength;
}
/**
* appends the bits
*/
private void getBits(BitArray bits) throws WriterException {
bits.appendBits(mode.getBits(), 4);
if (characterLength > 0) {
int length = getCharacterCountIndicator();
bits.appendBits(length, mode.getCharacterCountBits(version));
}
if (mode == Mode.ECI) {
bits.appendBits(encoders.getECIValue(charsetEncoderIndex), 8);
} else if (characterLength > 0) {
// append data
Encoder.appendBytes(stringToEncode.substring(fromPosition, fromPosition + characterLength), mode, bits,
encoders.getCharset(charsetEncoderIndex));
}
}
public String toString() {
StringBuilder result = new StringBuilder();
result.append(mode).append('(');
if (mode == Mode.ECI) {
result.append(encoders.getCharset(charsetEncoderIndex).displayName());
} else {
result.append(makePrintable(stringToEncode.substring(fromPosition, fromPosition + characterLength)));
}
result.append(')');
return result.toString();
}
private String makePrintable(String s) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) < 32 || s.charAt(i) > 126) {
result.append('.');
} else {
result.append(s.charAt(i));
}
}
return result.toString();
}
}
}
}

403
src/qrcode/encoder/Encoder.java → src/qrcode/encoder/encoder.rs
View File

@@ -14,53 +14,58 @@
* limitations under the License. * limitations under the License.
*/ */
package com.google.zxing.qrcode.encoder; // package com.google.zxing.qrcode.encoder;
import com.google.zxing.EncodeHintType; // import com.google.zxing.EncodeHintType;
import com.google.zxing.WriterException; // import com.google.zxing.WriterException;
import com.google.zxing.common.BitArray; // import com.google.zxing.common.BitArray;
import com.google.zxing.common.StringUtils; // import com.google.zxing.common.StringUtils;
import com.google.zxing.common.CharacterSetECI; // import com.google.zxing.common.CharacterSetECI;
import com.google.zxing.common.reedsolomon.GenericGF; // import com.google.zxing.common.reedsolomon.GenericGF;
import com.google.zxing.common.reedsolomon.ReedSolomonEncoder; // import com.google.zxing.common.reedsolomon.ReedSolomonEncoder;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel; // import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import com.google.zxing.qrcode.decoder.Mode; // import com.google.zxing.qrcode.decoder.Mode;
import com.google.zxing.qrcode.decoder.Version; // import com.google.zxing.qrcode.decoder.Version;
import java.nio.charset.Charset; // import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets; // import java.nio.charset.StandardCharsets;
import java.util.ArrayList; // import java.util.ArrayList;
import java.util.Collection; // import java.util.Collection;
import java.util.Map; // import java.util.Map;
use std::collections::HashMap;
use encoding::EncodingRef;
use crate::{EncodingHintDictionary, common::{BitArray, CharacterSetECI, reedsolomon::{ReedSolomonEncoder, get_predefined_genericgf, PredefinedGenericGF}, StringUtils}, Exceptions, qrcode::decoder::{ErrorCorrectionLevel, Mode, VersionRef, Version}};
use super::{mask_util, ByteMatrix, QRCode, matrix_util};
/** /**
* @author satorux@google.com (Satoru Takabayashi) - creator * @author satorux@google.com (Satoru Takabayashi) - creator
* @author dswitkin@google.com (Daniel Switkin) - ported from C++ * @author dswitkin@google.com (Daniel Switkin) - ported from C++
*/ */
public final class Encoder {
// The original table is defined in the table 5 of JISX0510:2004 (p.19). // The original table is defined in the table 5 of JISX0510:2004 (p.19).
private static final int[] ALPHANUMERIC_TABLE = { const ALPHANUMERIC_TABLE : [i8;96]= [
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f
36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f
-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f
}; ];
static final Charset DEFAULT_BYTE_MODE_ENCODING = StandardCharsets.ISO_8859_1; const DEFAULT_BYTE_MODE_ENCODING : EncodingRef = encoding::all::ISO_8859_1;
private Encoder() {
}
// The mask penalty calculation is complicated. See Table 21 of JISX0510:2004 (p.45) for details. // The mask penalty calculation is complicated. See Table 21 of JISX0510:2004 (p.45) for details.
// Basically it applies four rules and summate all penalties. // Basically it applies four rules and summate all penalties.
private static int calculateMaskPenalty(ByteMatrix matrix) { pub fn calculateMaskPenalty( matrix:&ByteMatrix) -> u32{
return MaskUtil.applyMaskPenaltyRule1(matrix) return mask_util::applyMaskPenaltyRule1(matrix)
+ MaskUtil.applyMaskPenaltyRule2(matrix) + mask_util::applyMaskPenaltyRule2(matrix)
+ MaskUtil.applyMaskPenaltyRule3(matrix) + mask_util::applyMaskPenaltyRule3(matrix)
+ MaskUtil.applyMaskPenaltyRule4(matrix); + mask_util::applyMaskPenaltyRule4(matrix);
} }
/** /**
@@ -70,26 +75,26 @@ public final class Encoder {
* @throws WriterException if encoding can't succeed, because of for example invalid content * @throws WriterException if encoding can't succeed, because of for example invalid content
* or configuration * or configuration
*/ */
public static QRCode encode(String content, ErrorCorrectionLevel ecLevel) throws WriterException { pub fn encode( content:&str, ecLevel:&ErrorCorrectionLevel) -> Result<QRCode, Exceptions> {
return encode(content, ecLevel, null); return encode_with_hints(content, ecLevel, HashMap::new());
} }
public static QRCode encode(String content, pub fn encode_with_hints( content:&str,
ErrorCorrectionLevel ecLevel, ecLevel:&ErrorCorrectionLevel,
Map<EncodeHintType,?> hints) throws WriterException { hints:EncodingHintDictionary) -> Result<QRCode, Exceptions> {
Version version; let version;
BitArray headerAndDataBits; let headerAndDataBits;
Mode mode; let mode;
boolean hasGS1FormatHint = hints != null && hints.containsKey(EncodeHintType.GS1_FORMAT) && let hasGS1FormatHint = hints != null && hints.containsKey(EncodeHintType::GS1_FORMAT) &&
Boolean.parseBoolean(hints.get(EncodeHintType.GS1_FORMAT).toString()); Boolean.parseBoolean(hints.get(EncodeHintType::GS1_FORMAT).toString());
boolean hasCompactionHint = hints != null && hints.containsKey(EncodeHintType.QR_COMPACT) && let hasCompactionHint = hints != null && hints.containsKey(EncodeHintType::QR_COMPACT) &&
Boolean.parseBoolean(hints.get(EncodeHintType.QR_COMPACT).toString()); Boolean.parseBoolean(hints.get(EncodeHintType::QR_COMPACT).toString());
// Determine what character encoding has been specified by the caller, if any // Determine what character encoding has been specified by the caller, if any
Charset encoding = DEFAULT_BYTE_MODE_ENCODING; let encoding = DEFAULT_BYTE_MODE_ENCODING;
boolean hasEncodingHint = hints != null && hints.containsKey(EncodeHintType.CHARACTER_SET); let hasEncodingHint = hints != null && hints.containsKey(EncodeHintType::CHARACTER_SET);
if (hasEncodingHint) { if (hasEncodingHint) {
encoding = Charset.forName(hints.get(EncodeHintType.CHARACTER_SET).toString()); encoding = Charset.forName(hints.get(EncodeHintType.CHARACTER_SET).toString());
} }
@@ -191,7 +196,7 @@ public final class Encoder {
qrCode.setMaskPattern(maskPattern); qrCode.setMaskPattern(maskPattern);
// Build the matrix and set it to "qrCode". // Build the matrix and set it to "qrCode".
MatrixUtil.buildMatrix(finalBits, ecLevel, version, maskPattern, matrix); matrix_util::buildMatrix(finalBits, ecLevel, version, maskPattern, matrix);
qrCode.setMatrix(matrix); qrCode.setMatrix(matrix);
return qrCode; return qrCode;
@@ -202,25 +207,25 @@ public final class Encoder {
* *
* @throws WriterException if the data cannot fit in any version * @throws WriterException if the data cannot fit in any version
*/ */
private static Version recommendVersion(ErrorCorrectionLevel ecLevel, fn recommendVersion( ecLevel:&ErrorCorrectionLevel,
Mode mode, mode:Mode,
BitArray headerBits, headerBits:&BitArray,
BitArray dataBits) throws WriterException { dataBits:&BitArray) -> Result<VersionRef,Exceptions> {
// Hard part: need to know version to know how many bits length takes. But need to know how many // Hard part: need to know version to know how many bits length takes. But need to know how many
// bits it takes to know version. First we take a guess at version by assuming version will be // bits it takes to know version. First we take a guess at version by assuming version will be
// the minimum, 1: // the minimum, 1:
int provisionalBitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, Version.getVersionForNumber(1)); let provisionalBitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, Version::getVersionForNumber(1));
Version provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel); let provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel);
// Use that guess to calculate the right version. I am still not sure this works in 100% of cases. // Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
int bitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion); let bitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion);
return chooseVersion(bitsNeeded, ecLevel); return chooseVersion(bitsNeeded, ecLevel);
} }
private static int calculateBitsNeeded(Mode mode, fn calculateBitsNeeded( mode:Mode,
BitArray headerBits, headerBits:&BitArray,
BitArray dataBits, dataBits:&BitArray,
Version version) { version:VersionRef) -> u32 {
return headerBits.getSize() + mode.getCharacterCountBits(version) + dataBits.getSize(); return headerBits.getSize() + mode.getCharacterCountBits(version) + dataBits.getSize();
} }
@@ -228,22 +233,22 @@ public final class Encoder {
* @return the code point of the table used in alphanumeric mode or * @return the code point of the table used in alphanumeric mode or
* -1 if there is no corresponding code in the table. * -1 if there is no corresponding code in the table.
*/ */
static int getAlphanumericCode(int code) { pub fn getAlphanumericCode( code:u32) -> u32{
if (code < ALPHANUMERIC_TABLE.length) { if code < ALPHANUMERIC_TABLE.len() {
return ALPHANUMERIC_TABLE[code]; return ALPHANUMERIC_TABLE[code];
} }
return -1; return -1;
} }
public static Mode chooseMode(String content) { pub fn chooseMode( content:&str) -> Mode{
return chooseMode(content, null); return chooseModeWithEncoding(content, None);
} }
/** /**
* Choose the best mode by examining the content. Note that 'encoding' is used as a hint; * Choose the best mode by examining the content. Note that 'encoding' is used as a hint;
* if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}. * if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}.
*/ */
private static Mode chooseMode(String content, Charset encoding) { fn chooseModeWithEncoding( content:&str, encoding:Option<EncodingRef>) -> Mode{
if (StringUtils.SHIFT_JIS_CHARSET.equals(encoding) && isOnlyDoubleByteKanji(content)) { if (StringUtils.SHIFT_JIS_CHARSET.equals(encoding) && isOnlyDoubleByteKanji(content)) {
// Choose Kanji mode if all input are double-byte characters // Choose Kanji mode if all input are double-byte characters
return Mode.KANJI; return Mode.KANJI;
@@ -269,32 +274,36 @@ public final class Encoder {
return Mode.BYTE; return Mode.BYTE;
} }
static boolean isOnlyDoubleByteKanji(String content) { pub fn isOnlyDoubleByteKanji( content:&str) -> bool{
byte[] bytes = content.getBytes(StringUtils.SHIFT_JIS_CHARSET); let bytes = content.getBytes(StringUtils::SHIFT_JIS_CHARSET);
int length = bytes.length; let length = bytes.len();
if (length % 2 != 0) { if length % 2 != 0 {
return false; return false;
} }
for (int i = 0; i < length; i += 2) { let mut i = 0;
int byte1 = bytes[i] & 0xFF; while i < length {
if ((byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB)) { // for (int i = 0; i < length; i += 2) {
let byte1 = bytes[i] & 0xFF;
if (byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB) {
return false; return false;
} }
i+=2;
} }
return true; return true;
} }
private static int chooseMaskPattern(BitArray bits, fn chooseMaskPattern( bits:&BitArray,
ErrorCorrectionLevel ecLevel, ecLevel:&ErrorCorrectionLevel,
Version version, version:VersionRef,
ByteMatrix matrix) throws WriterException { matrix:&ByteMatrix) -> Result<u32, Exceptions> {
int minPenalty = Integer.MAX_VALUE; // Lower penalty is better. let minPenalty = u32::MAX; // Lower penalty is better.
int bestMaskPattern = -1; let bestMaskPattern = -1;
// We try all mask patterns to choose the best one. // We try all mask patterns to choose the best one.
for (int maskPattern = 0; maskPattern < QRCode.NUM_MASK_PATTERNS; maskPattern++) { for maskPattern in 0..QRCode::NUM_MASK_PATTERNS {
MatrixUtil.buildMatrix(bits, ecLevel, version, maskPattern, matrix); // for (int maskPattern = 0; maskPattern < QRCode.NUM_MASK_PATTERNS; maskPattern++) {
int penalty = calculateMaskPenalty(matrix); matrix_util::buildMatrix(bits, ecLevel, version, maskPattern, matrix);
let penalty = calculateMaskPenalty(matrix);
if (penalty < minPenalty) { if (penalty < minPenalty) {
minPenalty = penalty; minPenalty = penalty;
bestMaskPattern = maskPattern; bestMaskPattern = maskPattern;
@@ -303,38 +312,39 @@ public final class Encoder {
return bestMaskPattern; return bestMaskPattern;
} }
private static Version chooseVersion(int numInputBits, ErrorCorrectionLevel ecLevel) throws WriterException { fn chooseVersion( numInputBits:u32, ecLevel:&ErrorCorrectionLevel) -> Result<VersionRef,Exceptions> {
for (int versionNum = 1; versionNum <= 40; versionNum++) { for versionNum in 1..=40 {
Version version = Version.getVersionForNumber(versionNum); // for (int versionNum = 1; versionNum <= 40; versionNum++) {
if (willFit(numInputBits, version, ecLevel)) { let version = Version::getVersionForNumber(versionNum);
if willFit(numInputBits, version, ecLevel) {
return version; return version;
} }
} }
throw new WriterException("Data too big"); Err(Exceptions::WriterException("Data too big".to_owned()));
} }
/** /**
* @return true if the number of input bits will fit in a code with the specified version and * @return true if the number of input bits will fit in a code with the specified version and
* error correction level. * error correction level.
*/ */
static boolean willFit(int numInputBits, Version version, ErrorCorrectionLevel ecLevel) { pub fn willFit( numInputBits:u32, version:VersionRef, ecLevel:&ErrorCorrectionLevel) -> bool {
// In the following comments, we use numbers of Version 7-H. // In the following comments, we use numbers of Version 7-H.
// numBytes = 196 // numBytes = 196
int numBytes = version.getTotalCodewords(); let numBytes = version.getTotalCodewords();
// getNumECBytes = 130 // getNumECBytes = 130
Version.ECBlocks ecBlocks = version.getECBlocksForLevel(ecLevel); let ecBlocks = version.getECBlocksForLevel(ecLevel);
int numEcBytes = ecBlocks.getTotalECCodewords(); let numEcBytes = ecBlocks.getTotalECCodewords();
// getNumDataBytes = 196 - 130 = 66 // getNumDataBytes = 196 - 130 = 66
int numDataBytes = numBytes - numEcBytes; let numDataBytes = numBytes - numEcBytes;
int totalInputBytes = (numInputBits + 7) / 8; let totalInputBytes = (numInputBits + 7) / 8;
return numDataBytes >= totalInputBytes; return numDataBytes >= totalInputBytes;
} }
/** /**
* Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24). * Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).
*/ */
static void terminateBits(int numDataBytes, BitArray bits) throws WriterException { pub fn terminateBits( numDataBytes:u32, bits:&BitArray) -> Result<(),Exceptions> {
int capacity = numDataBytes * 8; let capacity = numDataBytes * 8;
if (bits.getSize() > capacity) { if (bits.getSize() > capacity) {
throw new WriterException("data bits cannot fit in the QR Code" + bits.getSize() + " > " + throw new WriterException("data bits cannot fit in the QR Code" + bits.getSize() + " > " +
capacity); capacity);
@@ -366,13 +376,13 @@ public final class Encoder {
* the result in "numDataBytesInBlock", and "numECBytesInBlock". See table 12 in 8.5.1 of * the result in "numDataBytesInBlock", and "numECBytesInBlock". See table 12 in 8.5.1 of
* JISX0510:2004 (p.30) * JISX0510:2004 (p.30)
*/ */
static void getNumDataBytesAndNumECBytesForBlockID(int numTotalBytes, pub fn getNumDataBytesAndNumECBytesForBlockID( numTotalBytes:u32,
int numDataBytes, numDataBytes:u32,
int numRSBlocks, numRSBlocks:u32,
int blockID, blockID:u32,
int[] numDataBytesInBlock, numDataBytesInBlock:&[u32],
int[] numECBytesInBlock) throws WriterException { numECBytesInBlock:&[u32]) -> Result<(),Exceptions> {
if (blockID >= numRSBlocks) { if blockID >= numRSBlocks {
throw new WriterException("Block ID too large"); throw new WriterException("Block ID too large");
} }
// numRsBlocksInGroup2 = 196 % 5 = 1 // numRsBlocksInGroup2 = 196 % 5 = 1
@@ -422,36 +432,37 @@ public final class Encoder {
* Interleave "bits" with corresponding error correction bytes. On success, store the result in * Interleave "bits" with corresponding error correction bytes. On success, store the result in
* "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details. * "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
*/ */
static BitArray interleaveWithECBytes(BitArray bits, pub fn interleaveWithECBytes( bits:&BitArray,
int numTotalBytes, numTotalBytes:u32,
int numDataBytes, numDataBytes:u32,
int numRSBlocks) throws WriterException { numRSBlocks:u32) -> Result<BitArray,Exceptions> {
// "bits" must have "getNumDataBytes" bytes of data. // "bits" must have "getNumDataBytes" bytes of data.
if (bits.getSizeInBytes() != numDataBytes) { if bits.getSizeInBytes() != numDataBytes {
throw new WriterException("Number of bits and data bytes does not match"); return Err(Exceptions::WriterException("Number of bits and data bytes does not match".to_owned()))
} }
// Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll // Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll
// store the divided data bytes blocks and error correction bytes blocks into "blocks". // store the divided data bytes blocks and error correction bytes blocks into "blocks".
int dataBytesOffset = 0; let dataBytesOffset = 0;
int maxNumDataBytes = 0; let maxNumDataBytes = 0;
int maxNumEcBytes = 0; let maxNumEcBytes = 0;
// Since, we know the number of reedsolmon blocks, we can initialize the vector with the number. // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.
Collection<BlockPair> blocks = new ArrayList<>(numRSBlocks); let blocks = Vec::new();
for (int i = 0; i < numRSBlocks; ++i) { for i in 0..numRSBlocks {
int[] numDataBytesInBlock = new int[1]; // for (int i = 0; i < numRSBlocks; ++i) {
int[] numEcBytesInBlock = new int[1]; let numDataBytesInBlock = new int[1];
let numEcBytesInBlock = new int[1];
getNumDataBytesAndNumECBytesForBlockID( getNumDataBytesAndNumECBytesForBlockID(
numTotalBytes, numDataBytes, numRSBlocks, i, numTotalBytes, numDataBytes, numRSBlocks, i,
numDataBytesInBlock, numEcBytesInBlock); numDataBytesInBlock, numEcBytesInBlock);
int size = numDataBytesInBlock[0]; let size = numDataBytesInBlock[0];
byte[] dataBytes = new byte[size]; let dataBytes = new byte[size];
bits.toBytes(8 * dataBytesOffset, dataBytes, 0, size); bits.toBytes(8 * dataBytesOffset, dataBytes, 0, size);
byte[] ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]); let ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]);
blocks.add(new BlockPair(dataBytes, ecBytes)); blocks.add(new BlockPair(dataBytes, ecBytes));
maxNumDataBytes = Math.max(maxNumDataBytes, size); maxNumDataBytes = Math.max(maxNumDataBytes, size);
@@ -459,10 +470,10 @@ public final class Encoder {
dataBytesOffset += numDataBytesInBlock[0]; dataBytesOffset += numDataBytesInBlock[0];
} }
if (numDataBytes != dataBytesOffset) { if (numDataBytes != dataBytesOffset) {
throw new WriterException("Data bytes does not match offset"); return Err(Exceptions::WriterException("Data bytes does not match offset".to_owned()))
} }
BitArray result = new BitArray(); let result = BitArray::new();
// First, place data blocks. // First, place data blocks.
for (int i = 0; i < maxNumDataBytes; ++i) { for (int i = 0; i < maxNumDataBytes; ++i) {
@@ -490,17 +501,20 @@ public final class Encoder {
return result; return result;
} }
static byte[] generateECBytes(byte[] dataBytes, int numEcBytesInBlock) { pub fn generateECBytes( dataBytes:&[u8], numEcBytesInBlock:u32) -> Vec<u8> {
int numDataBytes = dataBytes.length; let numDataBytes = dataBytes.length;
int[] toEncode = new int[numDataBytes + numEcBytesInBlock]; let toEncode = vec![0;numDataBytes + numEcBytesInBlock];
for (int i = 0; i < numDataBytes; i++) { for i in 0..numDataBytes {
// for (int i = 0; i < numDataBytes; i++) {
toEncode[i] = dataBytes[i] & 0xFF; toEncode[i] = dataBytes[i] & 0xFF;
} }
new ReedSolomonEncoder(GenericGF.QR_CODE_FIELD_256).encode(toEncode, numEcBytesInBlock);
ReedSolomonEncoder::new(get_predefined_genericgf(PredefinedGenericGF::QrCodeField256)).encode(&mut toEncode, numEcBytesInBlock);
byte[] ecBytes = new byte[numEcBytesInBlock]; let ecBytes = vec![0u8;numEcBytesInBlock];
for (int i = 0; i < numEcBytesInBlock; i++) { for i in 0..numEcBytesInBlock {
ecBytes[i] = (byte) toEncode[numDataBytes + i]; // for (int i = 0; i < numEcBytesInBlock; i++) {
ecBytes[i] = toEncode[numDataBytes + i];
} }
return ecBytes; return ecBytes;
} }
@@ -508,7 +522,7 @@ public final class Encoder {
/** /**
* Append mode info. On success, store the result in "bits". * Append mode info. On success, store the result in "bits".
*/ */
static void appendModeInfo(Mode mode, BitArray bits) { pub fn appendModeInfo( mode:Mode, bits:&BitArray) {
bits.appendBits(mode.getBits(), 4); bits.appendBits(mode.getBits(), 4);
} }
@@ -516,75 +530,84 @@ public final class Encoder {
/** /**
* Append length info. On success, store the result in "bits". * Append length info. On success, store the result in "bits".
*/ */
static void appendLengthInfo(int numLetters, Version version, Mode mode, BitArray bits) throws WriterException { pub fn appendLengthInfo( numLetters:u32, version:VersionRef, mode:Mode, bits:&BitArray) -> Result<(),Exceptions> {
int numBits = mode.getCharacterCountBits(version); let numBits = mode.getCharacterCountBits(version);
if (numLetters >= (1 << numBits)) { if numLetters >= (1 << numBits) {
throw new WriterException(numLetters + " is bigger than " + ((1 << numBits) - 1)); return Err(Exceptions::WriterExceptin(format!("{} is bigger than {}" ,numLetters , ((1 << numBits) - 1))))
} }
bits.appendBits(numLetters, numBits); bits.appendBits(numLetters, numBits);
Ok(())
} }
/** /**
* Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits". * Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
*/ */
static void appendBytes(String content, pub fn appendBytes( content:&str,
Mode mode, mode:Mode,
BitArray bits, bits:&BitArray,
Charset encoding) throws WriterException { encoding:EncodingRef) -> Result<(),Exceptions>{
switch (mode) { match mode {
case NUMERIC: Mode::NUMERIC => Ok(appendNumericBytes(content, bits)),
appendNumericBytes(content, bits); Mode::ALPHANUMERIC => Ok(appendAlphanumericBytes(content, bits)),
break; Mode::BYTE => Ok(append8BitBytes(content, bits, encoding)),
case ALPHANUMERIC: Mode::KANJI => Ok(appendKanjiBytes(content, bits)),
appendAlphanumericBytes(content, bits); _=> Err(Exceptions::WriterException(format!("Invalid mode: {}" , mode)))
break; }
case BYTE: // switch (mode) {
append8BitBytes(content, bits, encoding); // case NUMERIC:
break; // appendNumericBytes(content, bits);
case KANJI: // break;
appendKanjiBytes(content, bits); // case ALPHANUMERIC:
break; // appendAlphanumericBytes(content, bits);
default: // break;
throw new WriterException("Invalid mode: " + mode); // case BYTE:
} // append8BitBytes(content, bits, encoding);
// break;
// case KANJI:
// appendKanjiBytes(content, bits);
// break;
// default:
// throw new WriterException("Invalid mode: " + mode);
// }
} }
static void appendNumericBytes(CharSequence content, BitArray bits) { pub fn appendNumericBytes( content:&str, bits:&BitArray) {
int length = content.length(); let length = content.length();
int i = 0; let i = 0;
while (i < length) { while i < length {
int num1 = content.charAt(i) - '0'; let num1 = content.charAt(i) - '0';
if (i + 2 < length) { if i + 2 < length {
// Encode three numeric letters in ten bits. // Encode three numeric letters in ten bits.
int num2 = content.charAt(i + 1) - '0'; let num2 = content.charAt(i + 1) - '0';
int num3 = content.charAt(i + 2) - '0'; let num3 = content.charAt(i + 2) - '0';
bits.appendBits(num1 * 100 + num2 * 10 + num3, 10); bits.appendBits(num1 * 100 + num2 * 10 + num3, 10);
i += 3; i += 3;
} else if (i + 1 < length) { } else if i + 1 < length {
// Encode two numeric letters in seven bits. // Encode two numeric letters in seven bits.
int num2 = content.charAt(i + 1) - '0'; let num2 = content.charAt(i + 1) - '0';
bits.appendBits(num1 * 10 + num2, 7); bits.appendBits(num1 * 10 + num2, 7);
i += 2; i += 2;
} else { } else {
// Encode one numeric letter in four bits. // Encode one numeric letter in four bits.
bits.appendBits(num1, 4); bits.appendBits(num1, 4);
i++; i+=1;
} }
} }
} }
static void appendAlphanumericBytes(CharSequence content, BitArray bits) throws WriterException { pub fn appendAlphanumericBytes( content:&str, bits:&BitArray) -> Result<(),Exceptions> {
int length = content.length(); let length = content.len();
int i = 0; let i = 0;
while (i < length) { while i < length {
int code1 = getAlphanumericCode(content.charAt(i)); let code1 = getAlphanumericCode(content.charAt(i));
if (code1 == -1) { if code1 == -1 {
throw new WriterException(); return Err(Exceptions::WriterException("".to_owned()));
} }
if (i + 1 < length) { if i + 1 < length {
int code2 = getAlphanumericCode(content.charAt(i + 1)); let code2 = getAlphanumericCode(content.charAt(i + 1));
if (code2 == -1) { if (code2 == -1) {
throw new WriterException(); return Err(Exceptions::WriterException("".to_owned()));
} }
// Encode two alphanumeric letters in 11 bits. // Encode two alphanumeric letters in 11 bits.
bits.appendBits(code1 * 45 + code2, 11); bits.appendBits(code1 * 45 + code2, 11);
@@ -592,46 +615,52 @@ public final class Encoder {
} else { } else {
// Encode one alphanumeric letter in six bits. // Encode one alphanumeric letter in six bits.
bits.appendBits(code1, 6); bits.appendBits(code1, 6);
i++; i+=1;
} }
} }
Ok(())
} }
static void append8BitBytes(String content, BitArray bits, Charset encoding) { fn append8BitBytes( content:&str, bits:&BitArray, encoding:EncodingRef) {
byte[] bytes = content.getBytes(encoding); let bytes = content.getBytes(encoding);
for (byte b : bytes) { for b in bytes {
// for (byte b : bytes) {
bits.appendBits(b, 8); bits.appendBits(b, 8);
} }
} }
static void appendKanjiBytes(String content, BitArray bits) throws WriterException { fn appendKanjiBytes( content:&str, bits:&BitArray) -> Result<(),Exceptions> {
byte[] bytes = content.getBytes(StringUtils.SHIFT_JIS_CHARSET); let bytes = content.getBytes(StringUtils::SHIFT_JIS_CHARSET);
if (bytes.length % 2 != 0) { if bytes.length % 2 != 0 {
throw new WriterException("Kanji byte size not even"); return Err(Exceptions::WriterException("Kanji byte size not even".to_owned()))
} }
int maxI = bytes.length - 1; // bytes.length must be even let maxI = bytes.length - 1; // bytes.length must be even
for (int i = 0; i < maxI; i += 2) { let mut i = 0;
int byte1 = bytes[i] & 0xFF; while i < maxI {
int byte2 = bytes[i + 1] & 0xFF; // for (int i = 0; i < maxI; i += 2) {
int code = (byte1 << 8) | byte2; let byte1 = bytes[i] & 0xFF;
int subtracted = -1; let byte2 = bytes[i + 1] & 0xFF;
if (code >= 0x8140 && code <= 0x9ffc) { let code = (byte1 << 8) | byte2;
let subtracted = -1;
if code >= 0x8140 && code <= 0x9ffc {
subtracted = code - 0x8140; subtracted = code - 0x8140;
} else if (code >= 0xe040 && code <= 0xebbf) { } else if (code >= 0xe040 && code <= 0xebbf) {
subtracted = code - 0xc140; subtracted = code - 0xc140;
} }
if (subtracted == -1) { if subtracted == -1 {
throw new WriterException("Invalid byte sequence"); return Err(Exceptions::WriterException("Invalid byte sequence".to_owned()))
} }
int encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff); let encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff);
bits.appendBits(encoded, 13); bits.appendBits(encoded, 13);
i+=2;
} }
Ok(())
} }
private static void appendECI(CharacterSetECI eci, BitArray bits) { fn appendECI( eci:&CharacterSetECI, bits:&BitArray) {
bits.appendBits(Mode.ECI.getBits(), 4); bits.appendBits(Mode::ECI.getBits(), 4);
// This is correct for values up to 127, which is all we need now. // This is correct for values up to 127, which is all we need now.
bits.appendBits(eci.getValue(), 8); bits.appendBits(eci.getValue(), 8);
} }
}

818
src/qrcode/encoder/minimal_encoder.rs Normal file
View File

@@ -0,0 +1,818 @@
/*
* Copyright 2021 ZXing authors
*
* Licensed 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.
*/
use std::{fmt, rc::Rc};
use encoding::EncodingRef;
use crate::{common::{ECIEncoderSet, BitArray}, qrcode::decoder::{ErrorCorrectionLevel, Version, Mode, VersionRef}, Exceptions};
use super::encoder;
enum VersionSize {
SMALL,//("version 1-9"),
MEDIUM,//("version 10-26"),
LARGE,//("version 27-40");
// private final String description;
// VersionSize(String description) {
// this.description = description;
// }
// public String toString() {
// return description;
// }
}
impl fmt::Display for VersionSize {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!( f, "{}", match self {
VersionSize::SMALL => "version 1-9",
VersionSize::MEDIUM => "version 10-26",
VersionSize::LARGE => "version 27-40",
})
}
}
/**
* Encoder that encodes minimally
*
* Algorithm:
*
* The eleventh commandment was "Thou Shalt Compute" or "Thou Shalt Not Compute" - I forget which (Alan Perilis).
*
* This implementation computes. As an alternative, the QR-Code specification suggests heuristics like this one:
*
* If initial input data is in the exclusive subset of the Alphanumeric character set AND if there are less than
* [6,7,8] characters followed by data from the remainder of the 8-bit byte character set, THEN select the 8-
* bit byte mode ELSE select Alphanumeric mode;
*
* This is probably right for 99.99% of cases but there is at least this one counter example: The string "AAAAAAa"
* encodes 2 bits smaller as ALPHANUMERIC(AAAAAA), BYTE(a) than by encoding it as BYTE(AAAAAAa).
* Perhaps that is the only counter example but without having proof, it remains unclear.
*
* ECI switching:
*
* In multi language content the algorithm selects the most compact representation using ECI modes.
* For example the most compact representation of the string "\u0150\u015C" (O-double-acute, S-circumflex) is
* ECI(UTF-8), BYTE(\u0150\u015C) while prepending one or more times the same leading character as in
* "\u0150\u0150\u015C", the most compact representation uses two ECIs so that the string is encoded as
* ECI(ISO-8859-2), BYTE(\u0150\u0150), ECI(ISO-8859-3), BYTE(\u015C).
*
* @author Alex Geller
*/
pub struct MinimalEncoder {
stringToEncode: String,
isGS1: bool,
encoders: ECIEncoderSet,
ecLevel:ErrorCorrectionLevel,
}
impl MinimalEncoder {
/**
* Creates a MinimalEncoder
*
* @param stringToEncode The string to encode
* @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
* chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
* charset to encode any character in the input that can be encoded by it if the charset is among the
* supported charsets.
* @param isGS1 {@code true} if a FNC1 is to be prepended; {@code false} otherwise
* @param ecLevel The error correction level.
* @see RXingResultList#getVersion
*/
pub fn new( stringToEncode:String, priorityCharset: EncodingRef, isGS1:bool, ecLevel:ErrorCorrectionLevel) -> Self {
Self {
stringToEncode,
isGS1,
encoders: ECIEncoderSet::new(&stringToEncode, priorityCharset, -1),
ecLevel,
}
// let encoders = ECIEncoderSet::new(&stringToEncode, priorityCharset, -1);
}
/**
* Encodes the string minimally
*
* @param stringToEncode The string to encode
* @param version The preferred {@link Version}. A minimal version is computed (see
* {@link RXingResultList#getVersion method} when the value of the argument is null
* @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
* chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
* charset to encode any character in the input that can be encoded by it if the charset is among the
* supported charsets.
* @param isGS1 {@code true} if a FNC1 is to be prepended; {@code false} otherwise
* @param ecLevel The error correction level.
* @return An instance of {@code RXingResultList} representing the minimal solution.
* @see RXingResultList#getBits
* @see RXingResultList#getVersion
* @see RXingResultList#getSize
*/
pub fn encode_with_details<'a>( stringToEncode:String, version:VersionRef, priorityCharset:EncodingRef, isGS1:bool,
ecLevel:ErrorCorrectionLevel) -> Result<RXingResultList<'a>,Exceptions> {
MinimalEncoder::new(stringToEncode, priorityCharset, isGS1, ecLevel).encode(Some(version))
}
pub fn encode(&self, version:Option<VersionRef>) -> Result<RXingResultList,Exceptions> {
if version.is_none() { // compute minimal encoding trying the three version sizes.
let versions = [ Self::getVersion(VersionSize::SMALL),
Self::getVersion(VersionSize::MEDIUM),
Self::getVersion(VersionSize::LARGE) ];
let results = [ self.encodeSpecificVersion(&versions[0]),
self.encodeSpecificVersion(&versions[1]),
self.encodeSpecificVersion(&versions[2]) ];
let smallestSize = u32::MAX;
let smallestRXingResult = -1;
for i in 0..3 {
// for (int i = 0; i < 3; i++) {
let size = results[i].getSize();
if encoder::willFit(size, versions[i], self.ecLevel) && size < smallestSize {
smallestSize = size;
smallestRXingResult = i;
}
}
if smallestRXingResult < 0 {
return Err(Exceptions::WriterException("Data too big for any version".to_owned()));
}
return results[smallestRXingResult];
} else { // compute minimal encoding for a given version
let result = self.encodeSpecificVersion(version);
if !encoder::willFit(result.getSize(), Self::getVersion(Self::getVersionSize(result.getVersion())), self.ecLevel) {
return Err(Exceptions::WriterException(format!("Data too big for version {}" , version)));
}
return result;
}
}
pub fn getVersionSize( version:&Version) -> VersionSize {
return if version.getVersionNumber() <= 9 { VersionSize::SMALL} else {if version.getVersionNumber() <= 26
{VersionSize::MEDIUM} else {VersionSize::LARGE}};
}
pub fn getVersion( versionSize:VersionSize)->VersionRef {
match versionSize {
VersionSize::SMALL => Version::getVersionForNumber(9).expect("should always exist"),
VersionSize::MEDIUM => Version::getVersionForNumber(26).expect("should always exist"),
VersionSize::LARGE => Version::getVersionForNumber(40).expect("should always exist"),
}
// switch (versionSize) {
// case SMALL:
// return Version.getVersionForNumber(9);
// case MEDIUM:
// return Version.getVersionForNumber(26);
// case LARGE:
// default:
// return Version.getVersionForNumber(40);
// }
}
pub fn isNumeric( c:char) -> bool{
return c >= '0' && c <= '9';
}
pub fn isDoubleByteKanji( c:char) -> bool{
return encoder::isOnlyDoubleByteKanji(String.valueOf(c));
}
pub fn isAlphanumeric( c: char) -> bool{
return encoder::getAlphanumericCode(c) != -1;
}
pub fn canEncode(&self, mode:&Mode, c:char) -> bool {
match mode {
Mode::NUMERIC => Self::isNumeric(c),
Mode::ALPHANUMERIC => Self::isAlphanumeric(c),
Mode::STRUCTURED_APPEND => todo!(),
Mode::BYTE => true,
Mode::KANJI => Self::isDoubleByteKanji(c),
_=> false,// any character can be encoded as byte(s). Up to the caller to manage splitting into
// multiple bytes when String.getBytes(Charset) return more than one byte.
}
}
pub fn getCompactedOrdinal( mode:Option<Mode>) -> Result<u32,Exceptions>{
if mode.is_none() {
return Ok(0);
}
match &mode.unwrap() {
Mode::NUMERIC => Ok(2),
Mode::ALPHANUMERIC => Ok(1),
Mode::BYTE => Ok(3),
Mode::KANJI => Ok(0),
_=> Err(Exceptions::IllegalArgumentException(format!("Illegal mode {:?}", mode))),
}
// switch (mode) {
// case KANJI:
// return 0;
// case ALPHANUMERIC:
// return 1;
// case NUMERIC:
// return 2;
// case BYTE:
// return 3;
// default:
// throw new IllegalStateException("Illegal mode " + mode);
// }
}
pub fn addEdge(&self, edges:&Vec<Vec<Vec<&'_ Edge>>>, position:u32, edge:Option<&Edge>) {
let vertexIndex = position + edge.as_ref().unwrap().characterLength;
let modeEdges = edges[vertexIndex as usize][edge.as_ref().unwrap().charsetEncoderIndex as usize];
let modeOrdinal = Self::getCompactedOrdinal(Some(edge.as_ref().unwrap().mode)).expect("value") as usize;
if /*modeEdges[modeOrdinal] == null ||*/ modeEdges[modeOrdinal].cachedTotalSize > (&edge).unwrap().cachedTotalSize {
modeEdges[modeOrdinal] = edge.unwrap();
}
}
pub fn addEdges( &self, version:&Edge, edges:&Vec<Vec<Vec<Edge>>>, from:u32, previous:&Edge) {
let start = 0;
let end = self.encoders.len();
let priorityEncoderIndex = self.encoders.getPriorityEncoderIndex();
if priorityEncoderIndex >= 0 && self.encoders.canEncode(self.stringToEncode.chars().nth(from).unwrap(),priorityEncoderIndex) {
start = priorityEncoderIndex;
end = priorityEncoderIndex + 1;
}
for i in start..end {
// for (int i = start; i < end; i++) {
if self.encoders.canEncode(self.stringToEncode.chars().nth(from).unwrap(), i) {
self.addEdge(edges, from, Edge::new(Mode::BYTE, from, i, 1, previous, version));
}
}
if self.canEncode(Mode::KANJI, self.stringToEncode.chars().nth(from).unwrap()) {
self.addEdge(edges, from, Edge::(Mode::KANJI, from, 0, 1, previous, version));
}
let inputLength = self.stringToEncode.len();
if self.canEncode(Mode::ALPHANUMERIC, self.stringToEncode.charAt(from)) {
self.addEdge(edges, from, Edge::new(Mode::ALPHANUMERIC, from, 0, from + 1 >= inputLength ||
!self.canEncode(Mode::ALPHANUMERIC, self.stringToEncode.charAt(from + 1)) ? 1 : 2, previous, version));
}
if self.canEncode(Mode::NUMERIC, self.stringToEncode.chars().nth(from).unwrap()) {
self.addEdge(edges, from, Edge::new(Mode::NUMERIC, from, 0, from + 1 >= inputLength ||
!self.canEncode(Mode::NUMERIC, self.stringToEncode.charAt(from + 1)) ? 1 : from + 2 >= inputLength ||
!self.canEncode(Mode::NUMERIC, self.stringToEncode.charAt(from + 2)) ? 2 : 3, previous, version));
}
}
pub fn encodeSpecificVersion(&self, version:VersionRef) ->Result< RXingResultList, Exceptions >{
// @SuppressWarnings("checkstyle:lineLength")
/* A vertex represents a tuple of a position in the input, a mode and a character encoding where position 0
* denotes the position left of the first character, 1 the position left of the second character and so on.
* Likewise the end vertices are located after the last character at position stringToEncode.length().
*
* An edge leading to such a vertex encodes one or more of the characters left of the position that the vertex
* represents and encodes it in the same encoding and mode as the vertex on which the edge ends. In other words,
* all edges leading to a particular vertex encode the same characters in the same mode with the same character
* encoding. They differ only by their source vertices who are all located at i+1 minus the number of encoded
* characters.
*
* The edges leading to a vertex are stored in such a way that there is a fast way to enumerate the edges ending
* on a particular vertex.
*
* The algorithm processes the vertices in order of their position thereby performing the following:
*
* For every vertex at position i the algorithm enumerates the edges ending on the vertex and removes all but the
* shortest from that list.
* Then it processes the vertices for the position i+1. If i+1 == stringToEncode.length() then the algorithm ends
* and chooses the the edge with the smallest size from any of the edges leading to vertices at this position.
* Otherwise the algorithm computes all possible outgoing edges for the vertices at the position i+1
*
* Examples:
* The process is illustrated by showing the graph (edges) after each iteration from left to right over the input:
* An edge is drawn as follows "(" + fromVertex + ") -- " + encodingMode + "(" + encodedInput + ") (" +
* accumulatedSize + ") --> (" + toVertex + ")"
*
* Example 1 encoding the string "ABCDE":
* Note: This example assumes that alphanumeric encoding is only possible in multiples of two characters so that
* the example is both short and showing the principle. In reality this restriction does not exist.
*
* Initial situation
* (initial) -- BYTE(A) (20) --> (1_BYTE)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 1
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 2
* (initial) -- BYTE(A) (20) --> (1_BYTE)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC)
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- BYTE(C) (44) --> (3_BYTE)
* (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 3
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- BYTE(D) (64) --> (4_BYTE)
* (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
* (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Situation after adding edges to vertices at position 4
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE) -- BYTE(D) (44) --> (4_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC) -- BYTE(E) (55) --> (5_BYTE)
*
* Situation after adding edges to vertices at position 5
* (initial) -- BYTE(A) (20) --> (1_BYTE) -- BYTE(B) (28) --> (2_BYTE) -- BYTE(C) (36) --> (3_BYTE) -- BYTE(D) (44) --> (4_BYTE) -- BYTE(E) (52) --> (5_BYTE)
* (1_BYTE) -- ALPHANUMERIC(BC) (44) --> (3_ALPHANUMERIC) -- ALPHANUMERIC(DE) (55) --> (5_ALPHANUMERIC)
* (initial) -- ALPHANUMERIC(AB) (24) --> (2_ALPHANUMERIC) -- ALPHANUMERIC(CD) (35) --> (4_ALPHANUMERIC)
*
* Encoding as BYTE(ABCDE) has the smallest size of 52 and is hence chosen. The encodation ALPHANUMERIC(ABCD),
* BYTE(E) is longer with a size of 55.
*
* Example 2 encoding the string "XXYY" where X denotes a character unique to character set ISO-8859-2 and Y a
* character unique to ISO-8859-3. Both characters encode as double byte in UTF-8:
*
* Initial situation
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 1
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2)
* (1_BYTE_ISO-8859-2) -- BYTE(X) (72) --> (2_BYTE_UTF-8)
* (1_BYTE_ISO-8859-2) -- BYTE(X) (72) --> (2_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 2
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (80) --> (3_BYTE_UTF-8)
* (2_BYTE_ISO-8859-2) -- BYTE(Y) (80) --> (3_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 3
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (80) --> (4_BYTE_ISO-8859-3)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (112) --> (4_BYTE_UTF-8)
* (3_BYTE_ISO-8859-3) -- BYTE(Y) (112) --> (4_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8) -- BYTE(Y) (72) --> (3_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE) -- BYTE(Y) (72) --> (3_BYTE_UTF-16BE)
*
* Situation after adding edges to vertices at position 4
* (initial) -- BYTE(X) (32) --> (1_BYTE_ISO-8859-2) -- BYTE(X) (40) --> (2_BYTE_ISO-8859-2) -- BYTE(Y) (72) --> (3_BYTE_ISO-8859-3) -- BYTE(Y) (80) --> (4_BYTE_ISO-8859-3)
* (3_BYTE_UTF-8) -- BYTE(Y) (88) --> (4_BYTE_UTF-8)
* (3_BYTE_UTF-16BE) -- BYTE(Y) (88) --> (4_BYTE_UTF-16BE)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-8) -- BYTE(X) (56) --> (2_BYTE_UTF-8) -- BYTE(Y) (72) --> (3_BYTE_UTF-8)
* (initial) -- BYTE(X) (40) --> (1_BYTE_UTF-16BE) -- BYTE(X) (56) --> (2_BYTE_UTF-16BE) -- BYTE(Y) (72) --> (3_BYTE_UTF-16BE)
*
* Encoding as ECI(ISO-8859-2),BYTE(XX),ECI(ISO-8859-3),BYTE(YY) has the smallest size of 80 and is hence chosen.
* The encodation ECI(UTF-8),BYTE(XXYY) is longer with a size of 88.
*/
let inputLength = self.stringToEncode.len();
// Array that represents vertices. There is a vertex for every character, encoding and mode. The vertex contains
// a list of all edges that lead to it that have the same encoding and mode.
// The lists are created lazily
// The last dimension in the array below encodes the 4 modes KANJI, ALPHANUMERIC, NUMERIC and BYTE via the
// function getCompactedOrdinal(Mode)
let edges = vec![vec![vec![]]];//new Edge[inputLength + 1][encoders.length()][4];
self. addEdges(version, &edges, 0, None);
for i in 1..=inputLength {
// for (int i = 1; i <= inputLength; i++) {
for j in 0..self.encoders.len() {
// for (int j = 0; j < encoders.length(); j++) {
for k in 0..4 {
// for (int k = 0; k < 4; k++) {
if edges[i][j][k] != null && i < inputLength {
self.addEdges(version, edges, i, edges[i][j][k]);
}
}
}
}
let minimalJ = -1;
let minimalK = -1;
let minimalSize = u32::MAX;
for j in 0..self.encoders.len() {
// for (int j = 0; j < encoders.length(); j++) {
for k in 0..4 {
// for (int k = 0; k < 4; k++) {
if edges[inputLength][j][k] != null {
let edge = edges[inputLength][j][k];
if edge.cachedTotalSize < minimalSize {
minimalSize = edge.cachedTotalSize;
minimalJ = j;
minimalK = k;
}
}
}
}
if minimalJ < 0 {
return Err(Exceptions::WriterException(format!(r#"Internal error: failed to encode "{}"#,self.stringToEncode)));
}
Ok(RXingResultList::new(version, edges[inputLength][minimalJ][minimalK]))
}
}
struct Edge<'a> {
mode:Mode,
fromPosition:u32,
charsetEncoderIndex:u32,
characterLength:u32,
previous:Option<&'a Edge<'a>>,
cachedTotalSize:u32,
encoders:&'a ECIEncoderSet,
stringToEncode: &'a str,
}
impl Edge<'_> {
pub fn new( mode:Mode, fromPosition:u32, charsetEncoderIndex:u32, characterLength:u32, previous:Option<&'_ Edge>,
version:&Version, encoders: &'_ ECIEncoderSet, stringToEncode: &'_ str) -> Self {
let nci = if mode == Mode::BYTE || previous.is_none() {charsetEncoderIndex} else
{previous.as_ref().unwrap().charsetEncoderIndex};
Self {
mode,
fromPosition,
charsetEncoderIndex: nci,
characterLength,
previous,
stringToEncode,
cachedTotalSize: {
let size = if previous.is_some() {previous.as_ref().unwrap().cachedTotalSize} else {0};
let needECI = mode == Mode::BYTE &&
(previous.is_none() && nci != 0) || // at the beginning and charset is not ISO-8859-1
(previous.is_some() && nci != previous.as_ref().unwrap().charsetEncoderIndex);
if previous.is_none()|| mode != previous.as_ref().unwrap().mode || needECI {
size += 4 + mode.getCharacterCountBits(&version) as u32;
}
match mode {
Mode::NUMERIC => size += if characterLength == 1 {4} else {if characterLength == 2 {7} else {10}},
Mode::ALPHANUMERIC => size += if characterLength == 1 {6} else {11},
Mode::BYTE =>{
size += 8 * encoders.encode_string(&stringToEncode[fromPosition as usize..(fromPosition + characterLength)as usize],
charsetEncoderIndex as usize).len() as u32;
if needECI {
size += 4 + 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
}
},
Mode::KANJI => size += 13,
_=> {},
}
// switch (mode) {
// case KANJI:
// size += 13;
// break;
// case ALPHANUMERIC:
// size += characterLength == 1 ? 6 : 11;
// break;
// case NUMERIC:
// size += characterLength == 1 ? 4 : characterLength == 2 ? 7 : 10;
// break;
// case BYTE:
// size += 8 * encoders.encode(stringToEncode.substring(fromPosition, fromPosition + characterLength),
// charsetEncoderIndex).length;
// if (needECI) {
// size += 4 + 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
// }
// break;
// }
size
},
encoders
}
// this.mode = mode;
// this.fromPosition = fromPosition;
// this.charsetEncoderIndex = mode == Mode.BYTE || previous == null ? charsetEncoderIndex :
// previous.charsetEncoderIndex; // inherit the encoding if not of type BYTE
// this.characterLength = characterLength;
// this.previous = previous;
// int size = previous != null ? previous.cachedTotalSize : 0;
// boolean needECI = mode == Mode.BYTE &&
// (previous == null && this.charsetEncoderIndex != 0) || // at the beginning and charset is not ISO-8859-1
// (previous != null && this.charsetEncoderIndex != previous.charsetEncoderIndex);
// if (previous == null || mode != previous.mode || needECI) {
// size += 4 + mode.getCharacterCountBits(version);
// }
// switch (mode) {
// case KANJI:
// size += 13;
// break;
// case ALPHANUMERIC:
// size += characterLength == 1 ? 6 : 11;
// break;
// case NUMERIC:
// size += characterLength == 1 ? 4 : characterLength == 2 ? 7 : 10;
// break;
// case BYTE:
// size += 8 * encoders.encode(stringToEncode.substring(fromPosition, fromPosition + characterLength),
// charsetEncoderIndex).length;
// if (needECI) {
// size += 4 + 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
// }
// break;
// }
// cachedTotalSize = size;
}
}
struct RXingResultList<'a> {
list: Vec<RXingResultNode<'a>>,
version: VersionRef,
}
impl RXingResultList<'_> {
pub fn new( version:VersionRef, solution:&'_ Edge, isGS1:bool, ecLevel: &ErrorCorrectionLevel) -> Self {
let length = 0;
let current = Some(solution);
let containsECI = false;
let list = Vec::new();
while current.is_some() {
length += current.as_ref().unwrap().characterLength;
let previous = current.as_ref().unwrap().previous;
let needECI = current.as_ref().unwrap().mode == Mode::BYTE &&
(previous.is_none() && current.as_ref().unwrap().charsetEncoderIndex != 0) || // at the beginning and charset is not ISO-8859-1
(previous.is_some() && current.as_ref().unwrap().charsetEncoderIndex != previous.as_ref().unwrap().charsetEncoderIndex);
if needECI {
containsECI = true;
}
if previous.is_none() || previous.as_ref().unwrap().mode != current.as_ref().unwrap().mode || needECI {
list.push( RXingResultNode::new(current.mode, current.fromPosition, current.charsetEncoderIndex, length));
length = 0;
}
if needECI {
list.push( RXingResultNode::new(Mode::ECI, current.fromPosition, current.charsetEncoderIndex, 0));
}
current = previous;
}
// prepend FNC1 if needed. If the bits contain an ECI then the FNC1 must be preceeded by an ECI.
// If there is no ECI at the beginning then we put an ECI to the default charset (ISO-8859-1)
if isGS1 {
if let Some(first) = list.get(0){
// if first != null && first.mode != Mode.ECI && containsECI {
if first.mode != Mode::ECI && containsECI {
// prepend a default character set ECI
list.push(0, RXingResultNode::new(Mode::ECI, 0, 0, 0));
}}
let first = list.get(0).unwrap();
// prepend or insert a FNC1_FIRST_POSITION after the ECI (if any)
// if first != null && first.mode != Mode.ECI && containsECI {
list.push( RXingResultNode::new(Mode::FNC1_FIRST_POSITION, 0, 0, 0));
}
// set version to smallest version into which the bits fit.
let versionNumber = version.getVersionNumber();
let (lowerLimit,upperLimit) =
match MinimalEncoder::getVersionSize(&version) {
VersionSize::SMALL =>
(1,9),
VersionSize::MEDIUM=>(10,26),
_=>(27,40),
};
// let lowerLimit;
// let upperLimit;
// switch (getVersionSize(version)) {
// case SMALL:
// lowerLimit = 1;
// upperLimit = 9;
// break;
// case MEDIUM:
// lowerLimit = 10;
// upperLimit = 26;
// break;
// case LARGE:
// default:
// lowerLimit = 27;
// upperLimit = 40;
// break;
// }
let size = Self::internal_static_get_size(version,&list);
// increase version if needed
while versionNumber < upperLimit && !encoder::willFit(size, Version::getVersionForNumber(versionNumber),
ecLevel) {
versionNumber+=1;
}
// shrink version if possible
while versionNumber > lowerLimit && encoder::willFit(size, Version::getVersionForNumber(versionNumber - 1),
ecLevel) {
versionNumber-=1;
}
let version = Version::getVersionForNumber(versionNumber).unwrap();
Self {
list,
version,
}
}
/**
* returns the size in bits
*/
pub fn getSize(&self) -> u32{
self. getSizeLocal(self.version)
}
fn getSizeLocal(&self, version:VersionRef) -> u32{
let result = 0;
for resultNode in &self.list {
result += resultNode.getSize(version);
}
return result;
}
fn internal_static_get_size(version:VersionRef, list: &Vec<RXingResultNode>) {
let result = 0;
for resultNode in list {
result += resultNode.getSize(version);
}
return result;
}
/**
* appends the bits
*/
pub fn getBits(&self, bits:&BitArray) -> Result<(),Exceptions> {
for resultNode in &self.list {
resultNode.getBits(bits);
}
Ok(())
}
pub fn getVersion(&self) -> &Version{
&self. version
}
}
impl fmt::Display for RXingResultList<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut result = String::new();
let previous = None;
for current in &self.list {
// for (RXingResultNode current : list) {
if previous.is_some() {
result.push_str(",");
}
result.push_str(&current.to_string());
previous = Some(current);
}
write!(f,"{}", result)
}
}
struct RXingResultNode<'a> {
mode:Mode,
fromPosition:u32,
charsetEncoderIndex:u32,
characterLength:u32,
encoders:&'a ECIEncoderSet,
version: VersionRef,
stringToEncode: &'a str,
}
impl RXingResultNode<'_> {
pub fn new( mode:Mode, fromPosition:u32, charsetEncoderIndex:u32, characterLength:u32, encoders:&'_ ECIEncoderSet, stringToEncode: &'_ str, version: &'_ Version) -> Self {
Self {
mode,
fromPosition,
charsetEncoderIndex,
characterLength,
encoders,
stringToEncode,
version,
}
}
/**
* returns the size in bits
*/
fn getSize(&self, version:&Version) -> u32{
let size = 4 + self.mode.getCharacterCountBits(version) as u32;
match self.mode {
Mode::NUMERIC => {
size += (self.characterLength / 3) * 10;
let rest = self.characterLength % 3;
size += if rest == 1 {4} else { if rest == 2 {7} else {0}};
},
Mode::ALPHANUMERIC => {
size += (self.characterLength / 2) * 11;
size += if (self.characterLength % 2) == 1 {6} else {0};
},
Mode::BYTE => size += 8 * self.getCharacterCountIndicator(),
Mode::ECI => size += 8,
Mode::KANJI => size += 13 * self.characterLength,
_ => {},
}
// switch (mode) {
// case KANJI:
// size += 13 * characterLength;
// break;
// case ALPHANUMERIC:
// size += (characterLength / 2) * 11;
// size += (characterLength % 2) == 1 ? 6 : 0;
// break;
// case NUMERIC:
// size += (characterLength / 3) * 10;
// int rest = characterLength % 3;
// size += rest == 1 ? 4 : rest == 2 ? 7 : 0;
// break;
// case BYTE:
// size += 8 * getCharacterCountIndicator();
// break;
// case ECI:
// size += 8; // the ECI assignment numbers for ISO-8859-x, UTF-8 and UTF-16 are all 8 bit long
// }
size
}
/**
* returns the length in characters according to the specification (differs from getCharacterLength() in BYTE mode
* for multi byte encoded characters)
*/
fn getCharacterCountIndicator(&self) -> u32{
if self.mode == Mode::BYTE
{self.encoders.encode_string(&self.stringToEncode[self.fromPosition as usize..(self.fromPosition + self.characterLength) as usize],
self.charsetEncoderIndex as usize).len() as u32} else {self.characterLength}
}
/**
* appends the bits
*/
fn getBits(&self, bits:&BitArray) -> Result<(),Exceptions> {
bits.appendBits(self.mode.getBits() as u32, 4);
if self.characterLength > 0 {
let length = self.getCharacterCountIndicator();
bits.appendBits(length, self.mode.getCharacterCountBits(self.version.as_ref()) as usize);
}
if self.mode == Mode::ECI {
bits.appendBits(self.encoders.getECIValue(self.charsetEncoderIndex as usize), 8);
} else if self.characterLength > 0 {
// append data
encoder::appendBytes(self.stringToEncode[self.fromPosition as usize..(self.fromPosition + self.characterLength) as usize], self.mode, bits,
self.encoders.getCharset(self.charsetEncoderIndex as usize));
}
Ok(())
}
fn makePrintable( s:&str) -> String {
let mut result = String::new();
for i in 0..s.chars().count() {
// for (int i = 0; i < s.length(); i++) {
if (s.chars().nth(i).unwrap() as u8) < 32 || (s.chars().nth(i).unwrap() as u8) > 126 {
result.push('.');
} else {
result.push(s.chars().nth(i).unwrap());
}
}
result
}
}
impl fmt::Display for RXingResultNode<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let result = String::new();
result.push_str(&format!("{:?}",self.mode));
result.push('(');
if self.mode == Mode::ECI {
result.push_str(self.encoders.getCharset(self.charsetEncoderIndex as usize).name());
} else {
result.push_str(&Self::makePrintable(&self.stringToEncode[self.fromPosition as usize..(self.fromPosition + self.characterLength) as usize]));
}
result.push(')');
write!(f,"{}", result)
}
}

3
src/qrcode/encoder/mod.rs
View File

@@ -3,10 +3,13 @@ mod byte_matrix;
mod block_pair; mod block_pair;
pub mod mask_util; pub mod mask_util;
pub mod matrix_util; pub mod matrix_util;
mod minimal_encoder;
pub mod encoder;
pub use qr_code::*; pub use qr_code::*;
pub use byte_matrix::*; pub use byte_matrix::*;
pub use block_pair::*; pub use block_pair::*;
pub use minimal_encoder::*;
#[cfg(test)] #[cfg(test)]
mod QRCodeTestCase; mod QRCodeTestCase;