youys
/
shadowsocks-windows
Not watched
1
0
Fork 0
Code
Releases 67 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

remove some class

tags/2.3
clowwindy 10 years ago
parent
dce38883a5
commit
49d04316cd
6 changed files with 0 additions and 1191 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -152
      shadowsocks-csharp/3rd/zxing/BarcodeReader.cs
  2. +0
    -436
      shadowsocks-csharp/3rd/zxing/BarcodeReaderGeneric.cs
  3. +0
    -161
      shadowsocks-csharp/3rd/zxing/IBarcodeReader.cs
  4. +0
    -123
      shadowsocks-csharp/3rd/zxing/IBarcodeReaderGeneric.cs
  5. +0
    -314
      shadowsocks-csharp/3rd/zxing/RGBLuminanceSource.cs
  6. +0
    -5
      shadowsocks-csharp/shadowsocks-csharp.csproj

+ 0
- 152
shadowsocks-csharp/3rd/zxing/BarcodeReader.cs View File

@@ -1,152 +0,0 @@
/*
* Copyright 2012 ZXing.Net 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.
*/
using System;
#if !PORTABLE
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
using System.Drawing;
using ZXing.QrCode;
#else
using UnityEngine;
#endif
#elif NETFX_CORE
using Windows.UI.Xaml.Media.Imaging;
#else
using System.Windows.Media.Imaging;
#endif
#endif
#if MONOANDROID
using Android.Graphics;
#endif
namespace ZXing
{
/// <summary>
/// A smart class to decode the barcode inside a bitmap object
/// </summary>
#if MONOTOUCH
public class BarcodeReader : BarcodeReaderGeneric<MonoTouch.UIKit.UIImage>, IBarcodeReader, IMultipleBarcodeReader
{
private static readonly Func<MonoTouch.UIKit.UIImage, LuminanceSource> defaultCreateLuminanceSource =
(img) => new RGBLuminanceSource(img);
#else
#if !PORTABLE
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
public class BarcodeReader : BarcodeReaderGeneric<Bitmap>, IBarcodeReader
{
private static readonly Func<Bitmap, LuminanceSource> defaultCreateLuminanceSource =
(bitmap) => new BitmapLuminanceSource(bitmap);
#else
public class BarcodeReader : BarcodeReaderGeneric<Color32[]>, IBarcodeReader, IMultipleBarcodeReader
{
private static readonly Func<Color32[], int, int, LuminanceSource> defaultCreateLuminanceSource =
(rawColor32, width, height) => new Color32LuminanceSource(rawColor32, width, height);
#endif
#else
public class BarcodeReader : BarcodeReaderGeneric<WriteableBitmap>, IBarcodeReader, IMultipleBarcodeReader
{
private static readonly Func<WriteableBitmap, LuminanceSource> defaultCreateLuminanceSource =
(bitmap) => new BitmapLuminanceSource(bitmap);
#endif
#else
public class BarcodeReader : BarcodeReaderGeneric<byte[]>, IBarcodeReader, IMultipleBarcodeReader
{
private static readonly Func<byte[], LuminanceSource> defaultCreateLuminanceSource =
(data) => null;
#endif
#endif
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReader"/> class.
/// </summary>
public BarcodeReader()
: this(new QRCodeReader(), defaultCreateLuminanceSource, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReader"/> class.
/// </summary>
/// <param name="reader">Sets the reader which should be used to find and decode the barcode.
/// If null then MultiFormatReader is used</param>
/// <param name="createLuminanceSource">Sets the function to create a luminance source object for a bitmap.
/// If null, an exception is thrown when Decode is called</param>
/// <param name="createBinarizer">Sets the function to create a binarizer object for a luminance source.
/// If null then HybridBinarizer is used</param>
public BarcodeReader(Reader reader,
#if MONOTOUCH
Func<MonoTouch.UIKit.UIImage, LuminanceSource> createLuminanceSource,
#elif MONOANDROID
Func<Android.Graphics.Bitmap, LuminanceSource> createLuminanceSource,
#else
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
#if !PORTABLE
Func<Bitmap, LuminanceSource> createLuminanceSource,
#else
Func<byte[], LuminanceSource> createLuminanceSource,
#endif
#else
Func<Color32[], int, int, LuminanceSource> createLuminanceSource,
#endif
#else
Func<WriteableBitmap, LuminanceSource> createLuminanceSource,
#endif
#endif
Func<LuminanceSource, Binarizer> createBinarizer
)
: base(reader, createLuminanceSource ?? defaultCreateLuminanceSource, createBinarizer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReader"/> class.
/// </summary>
/// <param name="reader">Sets the reader which should be used to find and decode the barcode.
/// If null then MultiFormatReader is used</param>
/// <param name="createLuminanceSource">Sets the function to create a luminance source object for a bitmap.
/// If null, an exception is thrown when Decode is called</param>
/// <param name="createBinarizer">Sets the function to create a binarizer object for a luminance source.
/// If null then HybridBinarizer is used</param>
public BarcodeReader(Reader reader,
#if MONOTOUCH
Func<MonoTouch.UIKit.UIImage, LuminanceSource> createLuminanceSource,
#elif MONOANDROID
Func<Android.Graphics.Bitmap, LuminanceSource> createLuminanceSource,
#else
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
#if !PORTABLE
Func<Bitmap, LuminanceSource> createLuminanceSource,
#else
Func<byte[], LuminanceSource> createLuminanceSource,
#endif
#else
Func<Color32[], int, int, LuminanceSource> createLuminanceSource,
#endif
#else
Func<WriteableBitmap, LuminanceSource> createLuminanceSource,
#endif
#endif
Func<LuminanceSource, Binarizer> createBinarizer,
Func<byte[], int, int, RGBLuminanceSource.BitmapFormat, LuminanceSource> createRGBLuminanceSource
)
: base(reader, createLuminanceSource ?? defaultCreateLuminanceSource, createBinarizer, createRGBLuminanceSource)
{
}
}
}

+ 0
- 436
shadowsocks-csharp/3rd/zxing/BarcodeReaderGeneric.cs View File

@@ -1,436 +0,0 @@
/*
* Copyright 2012 ZXing.Net 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.
*/
using System;
using System.Collections.Generic;
using ZXing.Common;
using ZXing.QrCode;
namespace ZXing
{
/// <summary>
/// A smart class to decode the barcode inside a bitmap object
/// </summary>
public class BarcodeReaderGeneric<T> : IBarcodeReaderGeneric<T>
{
private static readonly Func<LuminanceSource, Binarizer> defaultCreateBinarizer =
(luminanceSource) => new HybridBinarizer(luminanceSource);
protected static readonly Func<byte[], int, int, RGBLuminanceSource.BitmapFormat, LuminanceSource> defaultCreateRGBLuminanceSource =
(rawBytes, width, height, format) => new RGBLuminanceSource(rawBytes, width, height, format);
private Reader reader;
private readonly Func<byte[], int, int, RGBLuminanceSource.BitmapFormat, LuminanceSource> createRGBLuminanceSource;
#if !UNITY
private readonly Func<T, LuminanceSource> createLuminanceSource;
#else
private readonly Func<T, int, int, LuminanceSource> createLuminanceSource;
#endif
private readonly Func<LuminanceSource, Binarizer> createBinarizer;
private bool usePreviousState;
private DecodingOptions options;
/// <summary>
/// Gets or sets the options.
/// </summary>
/// <value>
/// The options.
/// </value>
public DecodingOptions Options
{
get { return options ?? (options = new DecodingOptions()); }
set { options = value; }
}
/// <summary>
/// Gets the reader which should be used to find and decode the barcode.
/// </summary>
/// <value>
/// The reader.
/// </value>
protected Reader Reader
{
get
{
return reader ?? (reader = new QRCodeReader());
}
}
/// <summary>
/// Gets or sets a method which is called if an important point is found
/// </summary>
/// <value>
/// The result point callback.
/// </value>
public event Action<ResultPoint> ResultPointFound
{
add
{
if (!Options.Hints.ContainsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK))
{
var callback = new ResultPointCallback(OnResultPointFound);
Options.Hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK] = callback;
}
explicitResultPointFound += value;
usePreviousState = false;
}
remove
{
explicitResultPointFound -= value;
if (explicitResultPointFound == null)
Options.Hints.Remove(DecodeHintType.NEED_RESULT_POINT_CALLBACK);
usePreviousState = false;
}
}
private event Action<ResultPoint> explicitResultPointFound;
/// <summary>
/// event is executed if a result was found via decode
/// </summary>
public event Action<Result> ResultFound;
/// <summary>
/// Gets or sets a flag which cause a deeper look into the bitmap
/// </summary>
/// <value>
/// <c>true</c> if [try harder]; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.TryHarder property instead.")]
public bool TryHarder
{
get { return Options.TryHarder; }
set { Options.TryHarder = value; }
}
/// <summary>
/// Image is a pure monochrome image of a barcode.
/// </summary>
/// <value>
/// <c>true</c> if monochrome image of a barcode; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.PureBarcode property instead.")]
public bool PureBarcode
{
get { return Options.PureBarcode; }
set { Options.PureBarcode = value; }
}
/// <summary>
/// Specifies what character encoding to use when decoding, where applicable (type String)
/// </summary>
/// <value>
/// The character set.
/// </value>
[Obsolete("Please use the Options.CharacterSet property instead.")]
public string CharacterSet
{
get { return Options.CharacterSet; }
set { Options.CharacterSet = value; }
}
/// <summary>
/// Image is known to be of one of a few possible formats.
/// Maps to a {@link java.util.List} of {@link BarcodeFormat}s.
/// </summary>
/// <value>
/// The possible formats.
/// </value>
[Obsolete("Please use the Options.PossibleFormats property instead.")]
public IList<BarcodeFormat> PossibleFormats
{
get { return Options.PossibleFormats; }
set { Options.PossibleFormats = value; }
}
/// <summary>
/// Gets or sets a value indicating whether the image should be automatically rotated.
/// Rotation is supported for 90, 180 and 270 degrees
/// </summary>
/// <value>
/// <c>true</c> if image should be rotated; otherwise, <c>false</c>.
/// </value>
public bool AutoRotate { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the image should be automatically inverted
/// if no result is found in the original image.
/// ATTENTION: Please be carefully because it slows down the decoding process if it is used
/// </summary>
/// <value>
/// <c>true</c> if image should be inverted; otherwise, <c>false</c>.
/// </value>
public bool TryInverted { get; set; }
#if !UNITY
/// <summary>
/// Optional: Gets or sets the function to create a luminance source object for a bitmap.
/// If null a platform specific default LuminanceSource is used
/// </summary>
/// <value>
/// The function to create a luminance source object.
/// </value>
protected Func<T, LuminanceSource> CreateLuminanceSource
#else
/// <summary>
/// Optional: Gets or sets the function to create a luminance source object for a bitmap.
/// If null a platform specific default LuminanceSource is used
/// </summary>
/// <value>
/// The function to create a luminance source object.
/// </value>
protected Func<T, int, int, LuminanceSource> CreateLuminanceSource
#endif
{
get
{
return createLuminanceSource;
}
}
/// <summary>
/// Optional: Gets or sets the function to create a binarizer object for a luminance source.
/// If null then HybridBinarizer is used
/// </summary>
/// <value>
/// The function to create a binarizer object.
/// </value>
protected Func<LuminanceSource, Binarizer> CreateBinarizer
{
get
{
return createBinarizer ?? defaultCreateBinarizer;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReaderGeneric{T}"/> class.
/// </summary>
public BarcodeReaderGeneric()
: this(new QRCodeReader(), null, defaultCreateBinarizer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReaderGeneric{T}"/> class.
/// </summary>
/// <param name="reader">Sets the reader which should be used to find and decode the barcode.
/// If null then MultiFormatReader is used</param>
/// <param name="createLuminanceSource">Sets the function to create a luminance source object for a bitmap.
/// If null, an exception is thrown when Decode is called</param>
/// <param name="createBinarizer">Sets the function to create a binarizer object for a luminance source.
/// If null then HybridBinarizer is used</param>
public BarcodeReaderGeneric(Reader reader,
#if !UNITY
Func<T, LuminanceSource> createLuminanceSource,
#else
Func<T, int, int, LuminanceSource> createLuminanceSource,
#endif
Func<LuminanceSource, Binarizer> createBinarizer
)
: this(reader, createLuminanceSource, createBinarizer, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeReaderGeneric{T}"/> class.
/// </summary>
/// <param name="reader">Sets the reader which should be used to find and decode the barcode.
/// If null then MultiFormatReader is used</param>
/// <param name="createLuminanceSource">Sets the function to create a luminance source object for a bitmap.
/// If null, an exception is thrown when Decode is called</param>
/// <param name="createBinarizer">Sets the function to create a binarizer object for a luminance source.
/// If null then HybridBinarizer is used</param>
/// <param name="createRGBLuminanceSource">Sets the function to create a luminance source object for a rgb array.
/// If null the RGBLuminanceSource is used. The handler is only called when Decode with a byte[] array is called.</param>
public BarcodeReaderGeneric(Reader reader,
#if !UNITY
Func<T, LuminanceSource> createLuminanceSource,
#else
Func<T, int, int, LuminanceSource> createLuminanceSource,
#endif
Func<LuminanceSource, Binarizer> createBinarizer,
Func<byte[], int, int, RGBLuminanceSource.BitmapFormat, LuminanceSource> createRGBLuminanceSource
)
{
this.reader = reader ?? new QRCodeReader();
this.createLuminanceSource = createLuminanceSource;
this.createBinarizer = createBinarizer ?? defaultCreateBinarizer;
this.createRGBLuminanceSource = createRGBLuminanceSource ?? defaultCreateRGBLuminanceSource;
Options.ValueChanged += (o, args) => usePreviousState = false;
usePreviousState = false;
}
#if !PORTABLE
#if !UNITY
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
public Result Decode(T barcodeBitmap)
#else
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="rawRGB">raw bytes of the image in RGB order</param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns>
/// the result data or null
/// </returns>
public Result Decode(T rawRGB, int width, int height)
#endif
{
if (CreateLuminanceSource == null)
{
throw new InvalidOperationException("You have to declare a luminance source delegate.");
}
#if !UNITY
if (barcodeBitmap == null)
throw new ArgumentNullException("barcodeBitmap");
#else
if (rawRGB == null)
throw new ArgumentNullException("rawRGB");
#endif
#if !UNITY
var luminanceSource = CreateLuminanceSource(barcodeBitmap);
#else
var luminanceSource = CreateLuminanceSource(rawRGB, width, height);
#endif
return Decode(luminanceSource);
}
#endif
/// <summary>
/// Tries to decode a barcode within an image which is given by a luminance source.
/// That method gives a chance to prepare a luminance source completely before calling
/// the time consuming decoding method. On the other hand there is a chance to create
/// a luminance source which is independent from external resources (like Bitmap objects)
/// and the decoding call can be made in a background thread.
/// </summary>
/// <param name="luminanceSource">The luminance source.</param>
/// <returns></returns>
virtual public Result Decode(LuminanceSource luminanceSource)
{
var result = default(Result);
var binarizer = CreateBinarizer(luminanceSource);
var binaryBitmap = new BinaryBitmap(binarizer);
var multiformatReader = Reader as QRCodeReader;
var rotationCount = 0;
var rotationMaxCount = 1;
if (AutoRotate)
{
Options.Hints[DecodeHintType.TRY_HARDER_WITHOUT_ROTATION] = true;
rotationMaxCount = 4;
}
else
{
if (Options.Hints.ContainsKey(DecodeHintType.TRY_HARDER_WITHOUT_ROTATION))
Options.Hints.Remove(DecodeHintType.TRY_HARDER_WITHOUT_ROTATION);
}
for (; rotationCount < rotationMaxCount; rotationCount++)
{
result = Reader.decode(binaryBitmap, Options.Hints);
usePreviousState = true;
if (result != null ||
!luminanceSource.RotateSupported ||
!AutoRotate)
break;
binaryBitmap = new BinaryBitmap(CreateBinarizer(luminanceSource.rotateCounterClockwise()));
}
if (result != null)
{
if (result.ResultMetadata == null)
{
result.putMetadata(ResultMetadataType.ORIENTATION, rotationCount * 90);
}
else if (!result.ResultMetadata.ContainsKey(ResultMetadataType.ORIENTATION))
{
result.ResultMetadata[ResultMetadataType.ORIENTATION] = rotationCount * 90;
}
else
{
// perhaps the core decoder rotates the image already (can happen if TryHarder is specified)
result.ResultMetadata[ResultMetadataType.ORIENTATION] = ((int)(result.ResultMetadata[ResultMetadataType.ORIENTATION]) + rotationCount * 90) % 360;
}
OnResultFound(result);
}
return result;
}
protected void OnResultsFound(IEnumerable<Result> results)
{
if (ResultFound != null)
{
foreach (var result in results)
{
ResultFound(result);
}
}
}
protected void OnResultFound(Result result)
{
if (ResultFound != null)
{
ResultFound(result);
}
}
protected void OnResultPointFound(ResultPoint resultPoint)
{
if (explicitResultPointFound != null)
{
explicitResultPointFound(resultPoint);
}
}
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="rawRGB">The image as byte[] array.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="format">The format.</param>
/// <returns>
/// the result data or null
/// </returns>
public Result Decode(byte[] rawRGB, int width, int height, RGBLuminanceSource.BitmapFormat format)
{
if (rawRGB == null)
throw new ArgumentNullException("rawRGB");
var luminanceSource = createRGBLuminanceSource(rawRGB, width, height, format);
return Decode(luminanceSource);
}
}
}

+ 0
- 161
shadowsocks-csharp/3rd/zxing/IBarcodeReader.cs View File

@@ -1,161 +0,0 @@
/*
* Copyright 2012 ZXing.Net 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.
*/
using System;
using System.Collections.Generic;
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
#if !PORTABLE
using System.Drawing;
#endif
#else
using UnityEngine;
#endif
#elif NETFX_CORE
using Windows.UI.Xaml.Media.Imaging;
#else
using System.Windows.Media.Imaging;
#endif
using ZXing.Common;
namespace ZXing
{
/// <summary>
/// Interface for a smart class to decode the barcode inside a bitmap object
/// </summary>
public interface IBarcodeReader
{
/// <summary>
/// event is executed when a result point was found
/// </summary>
event Action<ResultPoint> ResultPointFound;
/// <summary>
/// event is executed when a result was found via decode
/// </summary>
event Action<Result> ResultFound;
/// <summary>
/// Gets or sets a flag which cause a deeper look into the bitmap
/// </summary>
/// <value>
/// <c>true</c> if [try harder]; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.TryHarder property instead.")]
bool TryHarder { get; set; }
/// <summary>
/// Image is a pure monochrome image of a barcode.
/// </summary>
/// <value>
/// <c>true</c> if monochrome image of a barcode; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.PureBarcode property instead.")]
bool PureBarcode { get; set; }
/// <summary>
/// Specifies what character encoding to use when decoding, where applicable (type String)
/// </summary>
/// <value>
/// The character set.
/// </value>
[Obsolete("Please use the Options.CharacterSet property instead.")]
string CharacterSet { get; set; }
/// <summary>
/// Image is known to be of one of a few possible formats.
/// Maps to a {@link java.util.List} of {@link BarcodeFormat}s.
/// </summary>
/// <value>
/// The possible formats.
/// </value>
[Obsolete("Please use the Options.PossibleFormats property instead.")]
IList<BarcodeFormat> PossibleFormats { get; set; }
/// <summary>
/// Specifies some options which influence the decoding process
/// </summary>
DecodingOptions Options { get; set; }
/// <summary>
/// Decodes the specified barcode bitmap which is given by a generic byte array with the order RGB24.
/// </summary>
/// <param name="rawRGB">The image as RGB24 array.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="format">The format.</param>
/// <returns>
/// the result data or null
/// </returns>
Result Decode(byte[] rawRGB, int width, int height, RGBLuminanceSource.BitmapFormat format);
/// <summary>
/// Tries to decode a barcode within an image which is given by a luminance source.
/// That method gives a chance to prepare a luminance source completely before calling
/// the time consuming decoding method. On the other hand there is a chance to create
/// a luminance source which is independent from external resources (like Bitmap objects)
/// and the decoding call can be made in a background thread.
/// </summary>
/// <param name="luminanceSource">The luminance source.</param>
/// <returns></returns>
Result Decode(LuminanceSource luminanceSource);
#if MONOTOUCH
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(MonoTouch.UIKit.UIImage barcodeImage);
#elif MONOANDROID
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(Android.Graphics.Bitmap barcodeImage);
#else
#if !PORTABLE
#if !(SILVERLIGHT || NETFX_CORE)
#if !UNITY
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(Bitmap barcodeBitmap);
#else
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="rawColor32">The image as Color32 array.</param>
/// <returns>the result data or null</returns>
Result Decode(Color32[] rawColor32, int width, int height);
#endif
#else
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(WriteableBitmap barcodeBitmap);
#endif
#endif
#endif
}
}

+ 0
- 123
shadowsocks-csharp/3rd/zxing/IBarcodeReaderGeneric.cs View File

@@ -1,123 +0,0 @@
/*
* Copyright 2012 ZXing.Net 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.
*/
using System;
using System.Collections.Generic;
using ZXing.Common;
namespace ZXing
{
/// <summary>
/// Interface for a smart class to decode the barcode inside a bitmap object
/// </summary>
/// <typeparam name="T">gives the type of the input data</typeparam>
public interface IBarcodeReaderGeneric<T>
{
/// <summary>
/// event is executed when a result point was found
/// </summary>
event Action<ResultPoint> ResultPointFound;
/// <summary>
/// event is executed when a result was found via decode
/// </summary>
event Action<Result> ResultFound;
/// <summary>
/// Gets or sets a flag which cause a deeper look into the bitmap
/// </summary>
/// <value>
/// <c>true</c> if [try harder]; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.TryHarder property instead.")]
bool TryHarder { get; set; }
/// <summary>
/// Image is a pure monochrome image of a barcode.
/// </summary>
/// <value>
/// <c>true</c> if monochrome image of a barcode; otherwise, <c>false</c>.
/// </value>
[Obsolete("Please use the Options.PureBarcode property instead.")]
bool PureBarcode { get; set; }
/// <summary>
/// Specifies what character encoding to use when decoding, where applicable (type String)
/// </summary>
/// <value>
/// The character set.
/// </value>
[Obsolete("Please use the Options.CharacterSet property instead.")]
string CharacterSet { get; set; }
/// <summary>
/// Image is known to be of one of a few possible formats.
/// Maps to a {@link java.util.List} of {@link BarcodeFormat}s.
/// </summary>
/// <value>
/// The possible formats.
/// </value>
[Obsolete("Please use the Options.PossibleFormats property instead.")]
IList<BarcodeFormat> PossibleFormats { get; set; }
/// <summary>
/// Specifies some options which influence the decoding process
/// </summary>
DecodingOptions Options { get; set; }
/// <summary>
/// Decodes the specified barcode bitmap which is given by a generic byte array.
/// </summary>
/// <param name="rawRGB">The barcode bitmap.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="format">The format.</param>
/// <returns>
/// the result data or null
/// </returns>
Result Decode(byte[] rawRGB, int width, int height, RGBLuminanceSource.BitmapFormat format);
/// <summary>
/// Tries to decode a barcode within an image which is given by a luminance source.
/// That method gives a chance to prepare a luminance source completely before calling
/// the time consuming decoding method. On the other hand there is a chance to create
/// a luminance source which is independent from external resources (like Bitmap objects)
/// and the decoding call can be made in a background thread.
/// </summary>
/// <param name="luminanceSource">The luminance source.</param>
/// <returns></returns>
Result Decode(LuminanceSource luminanceSource);
#if !PORTABLE
#if !UNITY
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="barcodeBitmap">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(T barcodeBitmap);
#else
/// <summary>
/// Decodes the specified barcode bitmap.
/// </summary>
/// <param name="rawRGB">The barcode bitmap.</param>
/// <returns>the result data or null</returns>
Result Decode(T rawRGB, int width, int height);
#endif
#endif
}
}

+ 0
- 314
shadowsocks-csharp/3rd/zxing/RGBLuminanceSource.cs View File

@@ -1,314 +0,0 @@
/*
* Copyright 2012 ZXing.Net 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.
*/
using System;
namespace ZXing
{
/// <summary>
/// Luminance source class which support different formats of images.
/// </summary>
public partial class RGBLuminanceSource : BaseLuminanceSource
{
/// <summary>
/// enumeration of supported bitmap format which the RGBLuminanceSource can process
/// </summary>
public enum BitmapFormat
{
/// <summary>
/// format of the byte[] isn't known. RGBLuminanceSource tries to determine the best possible value
/// </summary>
Unknown,
/// <summary>
/// grayscale array, the byte array is a luminance array with 1 byte per pixel
/// </summary>
Gray8,
/// <summary>
/// 3 bytes per pixel with the channels red, green and blue
/// </summary>
RGB24,
/// <summary>
/// 4 bytes per pixel with the channels red, green and blue
/// </summary>
RGB32,
/// <summary>
/// 4 bytes per pixel with the channels alpha, red, green and blue
/// </summary>
ARGB32,
/// <summary>
/// 3 bytes per pixel with the channels blue, green and red
/// </summary>
BGR24,
/// <summary>
/// 4 bytes per pixel with the channels blue, green and red
/// </summary>
BGR32,
/// <summary>
/// 4 bytes per pixel with the channels blue, green, red and alpha
/// </summary>
BGRA32,
/// <summary>
/// 2 bytes per pixel, 5 bit red, 6 bits green and 5 bits blue
/// </summary>
RGB565,
/// <summary>
/// 4 bytes per pixel with the channels red, green, blue and alpha
/// </summary>
RGBA32,
}
/// <summary>
/// Initializes a new instance of the <see cref="RGBLuminanceSource"/> class.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
protected RGBLuminanceSource(int width, int height)
: base(width, height)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RGBLuminanceSource"/> class.
/// It supports a byte array with 3 bytes per pixel (RGB24).
/// </summary>
/// <param name="rgbRawBytes">The RGB raw bytes.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
public RGBLuminanceSource(byte[] rgbRawBytes, int width, int height)
: this(rgbRawBytes, width, height, BitmapFormat.RGB24)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RGBLuminanceSource"/> class.
/// It supports a byte array with 1 byte per pixel (Gray8).
/// That means the whole array consists of the luminance values (grayscale).
/// </summary>
/// <param name="luminanceArray">The luminance array.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="is8Bit">if set to <c>true</c> [is8 bit].</param>
[Obsolete("Use RGBLuminanceSource(luminanceArray, width, height, BitmapFormat.Gray8)")]
public RGBLuminanceSource(byte[] luminanceArray, int width, int height, bool is8Bit)
: this(luminanceArray, width, height, BitmapFormat.Gray8)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RGBLuminanceSource"/> class.
/// It supports a byte array with 3 bytes per pixel (RGB24).
/// </summary>
/// <param name="rgbRawBytes">The RGB raw bytes.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="bitmapFormat">The bitmap format.</param>
public RGBLuminanceSource(byte[] rgbRawBytes, int width, int height, BitmapFormat bitmapFormat)
: base(width, height)
{
CalculateLuminance(rgbRawBytes, bitmapFormat);
}
/// <summary>
/// Should create a new luminance source with the right class type.
/// The method is used in methods crop and rotate.
/// </summary>
/// <param name="newLuminances">The new luminances.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns></returns>
protected override LuminanceSource CreateLuminanceSource(byte[] newLuminances, int width, int height)
{
return new RGBLuminanceSource(width, height) { luminances = newLuminances };
}
private static BitmapFormat DetermineBitmapFormat(byte[] rgbRawBytes, int width, int height)
{
var square = width*height;
var byteperpixel = rgbRawBytes.Length/square;
switch (byteperpixel)
{
case 1:
return BitmapFormat.Gray8;
case 2:
return BitmapFormat.RGB565;
case 3:
return BitmapFormat.RGB24;
case 4:
return BitmapFormat.RGB32;
default:
throw new ArgumentException("The bitmap format could not be determined. Please specify the correct value.");
}
}
protected void CalculateLuminance(byte[] rgbRawBytes, BitmapFormat bitmapFormat)
{
if (bitmapFormat == BitmapFormat.Unknown)
{
bitmapFormat = DetermineBitmapFormat(rgbRawBytes, Width, Height);
}
switch (bitmapFormat)
{
case BitmapFormat.Gray8:
Buffer.BlockCopy(rgbRawBytes, 0, luminances, 0, rgbRawBytes.Length < luminances.Length ? rgbRawBytes.Length : luminances.Length);
break;
case BitmapFormat.RGB24:
CalculateLuminanceRGB24(rgbRawBytes);
break;
case BitmapFormat.BGR24:
CalculateLuminanceBGR24(rgbRawBytes);
break;
case BitmapFormat.RGB32:
CalculateLuminanceRGB32(rgbRawBytes);
break;
case BitmapFormat.BGR32:
CalculateLuminanceBGR32(rgbRawBytes);
break;
case BitmapFormat.RGBA32:
CalculateLuminanceRGBA32(rgbRawBytes);
break;
case BitmapFormat.ARGB32:
CalculateLuminanceARGB32(rgbRawBytes);
break;
case BitmapFormat.BGRA32:
CalculateLuminanceBGRA32(rgbRawBytes);
break;
case BitmapFormat.RGB565:
CalculateLuminanceRGB565(rgbRawBytes);
break;
default:
throw new ArgumentException("The bitmap format isn't supported.", bitmapFormat.ToString());
}
}
private void CalculateLuminanceRGB565(byte[] rgb565RawData)
{
var luminanceIndex = 0;
for (var index = 0; index < rgb565RawData.Length && luminanceIndex < luminances.Length; index += 2, luminanceIndex++)
{
var byte1 = rgb565RawData[index];
var byte2 = rgb565RawData[index + 1];
var b5 = byte1 & 0x1F;
var g5 = (((byte1 & 0xE0) >> 5) | ((byte2 & 0x03) << 3)) & 0x1F;
var r5 = (byte2 >> 2) & 0x1F;
var r8 = (r5 * 527 + 23) >> 6;
var g8 = (g5 * 527 + 23) >> 6;
var b8 = (b5 * 527 + 23) >> 6;
// cheap, not fully accurate conversion
//var pixel = (byte2 << 8) | byte1;
//b8 = (((pixel) & 0x001F) << 3);
//g8 = (((pixel) & 0x07E0) >> 2) & 0xFF;
//r8 = (((pixel) & 0xF800) >> 8);
luminances[luminanceIndex] = (byte)((RChannelWeight * r8 + GChannelWeight * g8 + BChannelWeight * b8) >> ChannelWeight);
}
}
private void CalculateLuminanceRGB24(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
int r = rgbRawBytes[rgbIndex++];
int g = rgbRawBytes[rgbIndex++];
int b = rgbRawBytes[rgbIndex++];
luminances[luminanceIndex] = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
}
}
private void CalculateLuminanceBGR24(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
int b = rgbRawBytes[rgbIndex++];
int g = rgbRawBytes[rgbIndex++];
int r = rgbRawBytes[rgbIndex++];
luminances[luminanceIndex] = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
}
}
private void CalculateLuminanceRGB32(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
int r = rgbRawBytes[rgbIndex++];
int g = rgbRawBytes[rgbIndex++];
int b = rgbRawBytes[rgbIndex++];
rgbIndex++;
luminances[luminanceIndex] = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
}
}
private void CalculateLuminanceBGR32(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
int b = rgbRawBytes[rgbIndex++];
int g = rgbRawBytes[rgbIndex++];
int r = rgbRawBytes[rgbIndex++];
rgbIndex++;
luminances[luminanceIndex] = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
}
}
private void CalculateLuminanceBGRA32(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
var b = rgbRawBytes[rgbIndex++];
var g = rgbRawBytes[rgbIndex++];
var r = rgbRawBytes[rgbIndex++];
var alpha = rgbRawBytes[rgbIndex++];
var luminance = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
luminances[luminanceIndex] = (byte)(((luminance * alpha) >> 8) + (255 * (255 - alpha) >> 8));
}
}
private void CalculateLuminanceRGBA32(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
var r = rgbRawBytes[rgbIndex++];
var g = rgbRawBytes[rgbIndex++];
var b = rgbRawBytes[rgbIndex++];
var alpha = rgbRawBytes[rgbIndex++];
var luminance = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
luminances[luminanceIndex] = (byte)(((luminance * alpha) >> 8) + (255 * (255 - alpha) >> 8));
}
}
private void CalculateLuminanceARGB32(byte[] rgbRawBytes)
{
for (int rgbIndex = 0, luminanceIndex = 0; rgbIndex < rgbRawBytes.Length && luminanceIndex < luminances.Length; luminanceIndex++)
{
// Calculate luminance cheaply, favoring green.
var alpha = rgbRawBytes[rgbIndex++];
var r = rgbRawBytes[rgbIndex++];
var g = rgbRawBytes[rgbIndex++];
var b = rgbRawBytes[rgbIndex++];
var luminance = (byte)((RChannelWeight * r + GChannelWeight * g + BChannelWeight * b) >> ChannelWeight);
luminances[luminanceIndex] = (byte)(((luminance * alpha) >> 8) + (255 * (255 - alpha) >> 8));
}
}
}
}

+ 0
- 5
shadowsocks-csharp/shadowsocks-csharp.csproj View File

@@ -71,8 +71,6 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="3rd\zxing\BarcodeFormat.cs" /> <Compile Include="3rd\zxing\BarcodeFormat.cs" />
<Compile Include="3rd\zxing\BarcodeReader.cs" />
<Compile Include="3rd\zxing\BarcodeReaderGeneric.cs" />
<Compile Include="3rd\zxing\BaseLuminanceSource.cs" /> <Compile Include="3rd\zxing\BaseLuminanceSource.cs" />
<Compile Include="3rd\zxing\Binarizer.cs" /> <Compile Include="3rd\zxing\Binarizer.cs" />
<Compile Include="3rd\zxing\BinaryBitmap.cs" /> <Compile Include="3rd\zxing\BinaryBitmap.cs" />
@@ -101,8 +99,6 @@
<Compile Include="3rd\zxing\common\StringUtils.cs" /> <Compile Include="3rd\zxing\common\StringUtils.cs" />
<Compile Include="3rd\zxing\DecodeHintType.cs" /> <Compile Include="3rd\zxing\DecodeHintType.cs" />
<Compile Include="3rd\zxing\EncodeHintType.cs" /> <Compile Include="3rd\zxing\EncodeHintType.cs" />
<Compile Include="3rd\zxing\IBarcodeReader.cs" />
<Compile Include="3rd\zxing\IBarcodeReaderGeneric.cs" />
<Compile Include="3rd\zxing\LuminanceSource.cs" /> <Compile Include="3rd\zxing\LuminanceSource.cs" />
<Compile Include="3rd\zxing\net2.0\Action.cs" /> <Compile Include="3rd\zxing\net2.0\Action.cs" />
<Compile Include="3rd\zxing\net2.0\Func.cs" /> <Compile Include="3rd\zxing\net2.0\Func.cs" />
@@ -138,7 +134,6 @@
<Compile Include="3rd\zxing\ResultMetadataType.cs" /> <Compile Include="3rd\zxing\ResultMetadataType.cs" />
<Compile Include="3rd\zxing\ResultPoint.cs" /> <Compile Include="3rd\zxing\ResultPoint.cs" />
<Compile Include="3rd\zxing\ResultPointCallback.cs" /> <Compile Include="3rd\zxing\ResultPointCallback.cs" />
<Compile Include="3rd\zxing\RGBLuminanceSource.cs" />
<Compile Include="3rd\zxing\WriterException.cs" /> <Compile Include="3rd\zxing\WriterException.cs" />
<Compile Include="Controller\AutoStartup.cs" /> <Compile Include="Controller\AutoStartup.cs" />
<Compile Include="Controller\FileManager.cs" /> <Compile Include="Controller\FileManager.cs" />


Write Preview
Loading…
Cancel
Save