From a92d783a3e357a2233923271185d933a9ea25f08 Mon Sep 17 00:00:00 2001 From: Henry Date: Sun, 21 Aug 2022 17:50:28 -0500 Subject: [PATCH] invertedluminancesource --- src/InvertedLuminanceSource.java | 88 ------------------------- src/lib.rs | 110 ++++++++++++++++++++++++++++++- 2 files changed, 109 insertions(+), 89 deletions(-) delete mode 100644 src/InvertedLuminanceSource.java diff --git a/src/InvertedLuminanceSource.java b/src/InvertedLuminanceSource.java deleted file mode 100644 index a64e15d..0000000 --- a/src/InvertedLuminanceSource.java +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright 2013 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; - -/** - * A wrapper implementation of {@link LuminanceSource} which inverts the luminances it returns -- black becomes - * white and vice versa, and each value becomes (255-value). - * - * @author Sean Owen - */ -public final class InvertedLuminanceSource extends LuminanceSource { - - private final LuminanceSource delegate; - - public InvertedLuminanceSource(LuminanceSource delegate) { - super(delegate.getWidth(), delegate.getHeight()); - this.delegate = delegate; - } - - @Override - public byte[] getRow(int y, byte[] row) { - row = delegate.getRow(y, row); - int width = getWidth(); - for (int i = 0; i < width; i++) { - row[i] = (byte) (255 - (row[i] & 0xFF)); - } - return row; - } - - @Override - public byte[] getMatrix() { - byte[] matrix = delegate.getMatrix(); - int length = getWidth() * getHeight(); - byte[] invertedMatrix = new byte[length]; - for (int i = 0; i < length; i++) { - invertedMatrix[i] = (byte) (255 - (matrix[i] & 0xFF)); - } - return invertedMatrix; - } - - @Override - public boolean isCropSupported() { - return delegate.isCropSupported(); - } - - @Override - public LuminanceSource crop(int left, int top, int width, int height) { - return new InvertedLuminanceSource(delegate.crop(left, top, width, height)); - } - - @Override - public boolean isRotateSupported() { - return delegate.isRotateSupported(); - } - - /** - * @return original delegate {@link LuminanceSource} since invert undoes itself - */ - @Override - public LuminanceSource invert() { - return delegate; - } - - @Override - public LuminanceSource rotateCounterClockwise() { - return new InvertedLuminanceSource(delegate.rotateCounterClockwise()); - } - - @Override - public LuminanceSource rotateCounterClockwise45() { - return new InvertedLuminanceSource(delegate.rotateCounterClockwise45()); - } - -} diff --git a/src/lib.rs b/src/lib.rs index b78e3d0..3101207 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1483,7 +1483,7 @@ pub trait LuminanceSource { * * @return A rotated version of this object. */ - fn rotateCounterClockwise45() -> Result { + fn rotateCounterClockwise45(&self) -> Result { return Err( UnsupportedOperationException::new("This luminance source does not support rotation by 45 degrees.")); } @@ -1514,3 +1514,111 @@ pub trait LuminanceSource { }*/ } + + +/* + * Copyright 2013 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; + +/** + * A wrapper implementation of {@link LuminanceSource} which inverts the luminances it returns -- black becomes + * white and vice versa, and each value becomes (255-value). + * + * @author Sean Owen + */ +pub struct InvertedLuminanceSource { + width:usize, + height:usize, + delegate:dyn LuminanceSource, +} + +impl InvertedLuminanceSource { + pub fn new_with_delegate( delegate:dyn LuminanceSource) -> Self { + Self { + width: delegate.getWidth(), + height: delegate.getHeight(), + delegate, + } + } +} + +impl LuminanceSource for InvertedLuminanceSource{ + fn new( width:usize, height:usize) -> Self { + let new_ils : Self; + new_ils.width = width; + new_ils.height = height; + + new_ils + } + + fn getRow(&self, y:usize, row:&Vec) -> Vec { + let new_row = self.delegate.getRow(y, row); + let width = self.getWidth(); + for i in 0..width{ + //for (int i = 0; i < width; i++) { + new_row[i] = (255 - (new_row[i] & 0xFF)); + } + return new_row; + } + + fn getMatrix(&self) -> Vec { + let matrix =self.delegate.getMatrix(); + let length = self.getWidth() * self.getHeight(); + let invertedMatrix = Vec::with_capacity(length); +for i in 0..length { + //for (int i = 0; i < length; i++) { + invertedMatrix[i] = (255 - (matrix[i] & 0xFF)); + } + return invertedMatrix; + } + + fn getWidth(&self) -> usize { + self.width + } + + fn getHeight(&self) -> usize { + self.height + } + + fn isCropSupported(&self) -> bool { + return self.delegate.isCropSupported(); + } + + fn crop(&self, left:usize, top:usize, width:usize, height:usize) -> Result { + return InvertedLuminanceSource::new_with_delegate(self.delegate.crop(left, top, width, height)); + } + + fn isRotateSupported(&self) -> bool { + return self.delegate.isRotateSupported(); + } + + /** + * @return original delegate {@link LuminanceSource} since invert undoes itself + */ + fn invert(&self) -> InvertedLuminanceSource{ + return self.delegate; + } + + fn rotateCounterClockwise(&self) -> Result { + return InvertedLuminanceSource::new_with_delegate(self.delegate.rotateCounterClockwise()); + } + + fn rotateCounterClockwise45(&self) -> Result { + return InvertedLuminanceSource::new_with_delegate(self.delegate.rotateCounterClockwise45()); + } + +}