Update README.md

Author: yushulx

.github/workflows/main.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest]
-        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10']
+        python-version: ['3.10']
 
     steps:
       - uses: actions/checkout@v2

README.md

@@ -1,27 +1,32 @@
 # Python Document Scanner SDK 
-The project is a Python binding to [Dynamsoft C/C++ Document Scanner SDK](https://www.dynamsoft.com/document-normalizer/docs/introduction/?ver=latest). It aims to help developers quickly build desktop document scanner applications in Python on Windows and Linux.
+This project provides Python bindings for the [Dynamsoft C/C++ Document Scanner SDK v1.x](https://www.dynamsoft.com/document-normalizer/docs/core/introduction/?ver=latest&ver=latest), enabling developers to quickly create document scanner applications for Windows and Linux desktop environments.
 
 ## About Dynamsoft Document Scanner
-Get a [30-day FREE trial license](https://www.dynamsoft.com/customer/license/trialLicense?product=ddn) to activate the SDK.
+- Activate the SDK with a [30-day FREE trial license](https://www.dynamsoft.com/customer/license/trialLicense?product=ddn).
 
 
-## Supported Python Edition
+## Supported Python Versions
 * Python 3.x
 
 ## Dependencies
+Install the required dependencies using pip:
 
 ```bash 
 pip install opencv-python
 ```
 
 ## Command-line Usage
-```bash 
-# Scan documents from images
-$ scandocument -f <file-name> -l <license-key>
+- Scan documents from images:
+    
+    ```bash
+    scandocument -f <file-name> -l <license-key>
+    ```
 
-# Scan documents from camera video stream
-$ scandocument -c 1 -l <license-key>
-```
+- Scan documents from a camera video stream:
+    
+    ```bash
+    scandocument -c 1 -l <license-key>
+    ```
 
 ## Quick Start
 - Scan documents from an image file:
@@ -80,7 +85,7 @@ $ scandocument -c 1 -l <license-key>
             
             # set license
             if  license == '':
-                docscanner.initLicense("DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTE2NDk4Mjk3OTI2MzUiLCJvcmdhbml6YXRpb25JRCI6IjIwMDAwMSIsInNlc3Npb25QYXNzd29yZCI6IndTcGR6Vm05WDJrcEQ5YUoifQ==")
+                docscanner.initLicense("LICENSE-KEY")
             else:
                 docscanner.initLicense(license)
                 
@@ -112,26 +117,29 @@ $ scandocument -c 1 -l <license-key>
     g_results = None
     g_normalized_images = []
 
+
     def callback(results):
         global g_results
         g_results = results
 
+
     def showNormalizedImage(name, normalized_image):
         mat = docscanner.convertNormalizedImage2Mat(normalized_image)
         cv2.imshow(name, mat)
         return mat
-        
+
+
     def process_video(scanner):
         scanner.addAsyncListener(callback)
-        
+
         cap = cv2.VideoCapture(0)
         while True:
             ret, image = cap.read()
-            
+
             ch = cv2.waitKey(1)
             if ch == 27:
                 break
-            elif ch == ord('n'): # normalize image
+            elif ch == ord('n'):  # normalize image
                 if g_results != None:
                     g_normalized_images = []
                     index = 0
@@ -144,23 +152,25 @@ $ scandocument -c 1 -l <license-key>
                         y3 = result.y3
                         x4 = result.x4
                         y4 = result.y4
-                        
-                        normalized_image = scanner.normalizeBuffer(image, x1, y1, x2, y2, x3, y3, x4, y4)
-                        g_normalized_images.append((str(index), normalized_image))
+
+                        normalized_image = scanner.normalizeBuffer(
+                            image, x1, y1, x2, y2, x3, y3, x4, y4)
+                        g_normalized_images.append(
+                            (str(index), normalized_image))
                         mat = showNormalizedImage(str(index), normalized_image)
                         index += 1
-            elif ch == ord('s'): # save image
+            elif ch == ord('s'):  # save image
                 for data in g_normalized_images:
                     # cv2.imwrite('images/' + str(time.time()) + '.png', image)
                     cv2.destroyWindow(data[0])
                     data[1].save(str(time.time()) + '.png')
                     print('Image saved')
-                    
+
                 g_normalized_images = []
-                
+
             if image is not None:
                 scanner.detectMatAsync(image)
-            
+
             if g_results != None:
                 for result in g_results:
                     x1 = result.x1
@@ -171,71 +181,48 @@ $ scandocument -c 1 -l <license-key>
                     y3 = result.y3
                     x4 = result.x4
                     y4 = result.y4
-                    
-                    cv2.drawContours(image, [np.intp([(x1, y1), (x2, y2), (x3, y3), (x4, y4)])], 0, (0, 255, 0), 2)
-                
-            cv2.putText(image, 'Press "n" to normalize image', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
-            cv2.putText(image, 'Press "s" to save image', (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
-            cv2.putText(image, 'Press "ESC" to exit', (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+
+                    cv2.drawContours(
+                        image, [np.intp([(x1, y1), (x2, y2), (x3, y3), (x4, y4)])], 0, (0, 255, 0), 2)
+
+            cv2.putText(image, 'Press "n" to normalize image',
+                        (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+            cv2.putText(image, 'Press "s" to save image', (10, 60),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+            cv2.putText(image, 'Press "ESC" to exit', (10, 90),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
             cv2.imshow('Document Scanner', image)
 
-    def scandocument():
-        """
-        Command-line script for scanning documents from camera video stream.
-        """
-        parser = argparse.ArgumentParser(description='Scan documents from camera')
-        parser.add_argument('-c', '--camera', default=False, type=bool, help='Whether to show the image')
-        parser.add_argument('-l', '--license', default='', type=str, help='Set a valid license key')
-        args = parser.parse_args()
-        # print(args)
-        try:
-            license = args.license
-            camera = args.camera
-            
-            if camera is False:
-                parser.print_help()
-                return
-            
-            # set license
-            if  license == '':
-                docscanner.initLicense("DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTE2NDk4Mjk3OTI2MzUiLCJvcmdhbml6YXRpb25JRCI6IjIwMDAwMSIsInNlc3Npb25QYXNzd29yZCI6IndTcGR6Vm05WDJrcEQ5YUoifQ==")
-            else:
-                docscanner.initLicense(license)
-                
-            # initialize mrz scanner
-            scanner = docscanner.createInstance()
-            ret = scanner.setParameters(docscanner.Templates.color)
 
-            if camera is True:
-                process_video(scanner)
-                
-        except Exception as err:
-            print(err)
-            sys.exit(1)
+    docscanner.initLicense(
+        "LICENSE-KEY")
+
+    scanner = docscanner.createInstance()
+    ret = scanner.setParameters(docscanner.Templates.color)
+    process_video(scanner)
 
-    scandocument()
     ```
     
     ![python document scanner from camera](https://www.dynamsoft.com/codepool/img/2022/09/python-document-scanner.png)
 
-## Methods
-- `docscanner.initLicense('YOUR-LICENSE-KEY')` # set the license key
+## API Methods
+- `docscanner.initLicense('YOUR-LICENSE-KEY')`: Set the license key.
     
     ```python
-    docscanner.initLicense("DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTE2NDk4Mjk3OTI2MzUiLCJvcmdhbml6YXRpb25JRCI6IjIwMDAwMSIsInNlc3Npb25QYXNzd29yZCI6IndTcGR6Vm05WDJrcEQ5YUoifQ==")
+    docscanner.initLicense("LICENSE-KEY")
     ```
 
-- `docscanner.createInstance()` # create a Document Scanner instance
+- `docscanner.createInstance()`: Create a Document Scanner instance.
     
     ```python
     scanner = docscanner.createInstance()
     ```
-- `detectFile(filename)` # do edge detection from an image file
+- `detectFile(filename)`: Perform edge detection from an image file.
 
     ```python
     results = scanner.detectFile(<filename>)
     ```
-- `detectMat(Mat image)` # do edge detection from Mat
+- `detectMat(Mat image)`: Perform edge detection from an OpenCV Mat.
     ```python
     image = cv2.imread(<filename>)
     results = scanner.detectMat(image)
@@ -250,14 +237,14 @@ $ scandocument -c 1 -l <license-key>
         y4 = result.y4
     ```
 
-- `setParameters(Template)` # Select color, binary or grayscale template
+- `setParameters(Template)`: Select color, binary, or grayscale template.
     
     ```python
     scanner.setParameters(docscanner.Templates.color)
     ```
 
-- `addAsyncListener(callback function)` # start a native thread to run document scanning tasks
-- `detectMatAsync(<opencv mat data>)` # put a document scanning task into the native queue
+- `addAsyncListener(callback function)`: Start a native thread to run document scanning tasks asynchronously.
+- `detectMatAsync(<opencv mat data>)`: Queue a document scanning task into the native thread.
     ```python
     def callback(results):
         for result in results:
@@ -277,23 +264,23 @@ $ scandocument -c 1 -l <license-key>
     sleep(5)
     ```
 
-- `normalizeBuffer(mat, x1, y1, x2, y2, x3, y3, x4, y4)` # do perspective correction from Mat
+- `normalizeBuffer(mat, x1, y1, x2, y2, x3, y3, x4, y4)`: Perform perspective correction from an OpenCV Mat.
+    
     ```python
     normalized_image = scanner.normalizeBuffer(image, x1, y1, x2, y2, x3, y3, x4, y4)
     ```
-- `normalizeFile(filename, x1, y1, x2, y2, x3, y3, x4, y4)` # do perspective correction from a file
+- `normalizeFile(filename, x1, y1, x2, y2, x3, y3, x4, y4)`: Perform perspective correction from an image file.
+    
     ```python
     normalized_image = scanner.normalizeFile(<filename>, x1, y1, x2, y2, x3, y3, x4, y4)
     ```
-- `normalized_image.save(filename)` # save the normalized image to a file
+- `normalized_image.save(filename)`: Save the normalized image to a file.
     ```python
     normalized_image.save(<filename>)
     ```
-- `normalized_image.recycle()` # release the memory of the normalized image
-- `clearAsyncListener()` # stop the native thread and clear the registered Python function
-## C/C++ API
-To customize Python API based on C/C++, please refer to the
-[online documentation](https://www.dynamsoft.com/document-normalizer/docs/programming/c/api-reference/?ver=latest).
+- `normalized_image.recycle()`: Release the memory of the normalized image.
+- `clearAsyncListener()`: Stop the native thread and clear the registered Python function.
+
 
 ## How to Build the Python Document Scanner Extension
 - Create a source distribution:

setup.py

@@ -84,7 +84,7 @@ def run(self):
 
 
 setup(name='document-scanner-sdk',
-      version='1.0.3',
+      version='1.1.0',
       description='Document Scanner SDK for document edge detection, border cropping, perspective correction and brightness adjustment',
       long_description=long_description,
       long_description_content_type="text/markdown",
@@ -112,8 +112,8 @@ def run(self):
           "Programming Language :: Python :: 3.8",
           "Programming Language :: Python :: 3.9",
           "Programming Language :: Python :: 3.10",
-		  "Programming Language :: Python :: 3.11",
-		  "Programming Language :: Python :: 3.12",
+          "Programming Language :: Python :: 3.11",
+          "Programming Language :: Python :: 3.12",
           "Programming Language :: C++",
           "Programming Language :: Python :: Implementation :: CPython",
           "Topic :: Scientific/Engineering",