issue-43: Added configurable area for decoding

spec/barcode_locator.spec.js

@@ -5,7 +5,8 @@ define(['barcode_locator', 'config', 'html_utils'],
     describe('checkImageConstraints', function() {
         var config,
             inputStream,
-            imageSize;
+            imageSize,
+            streamConfig = {};
 
         beforeEach(function() {
             imageSize = {
@@ -20,7 +21,12 @@ define(['barcode_locator', 'config', 'html_utils'],
                     return imageSize.y;
                 },
                 setWidth: function() {},
-                setHeight: function() {}
+                setHeight: function() {},
+                setTopRight: function() {},
+                setCanvasSize: function() {},
+                getConfig: function() {
+                    return streamConfig;
+                }
             };
             sinon.stub(inputStream, "setWidth", function(width) {
                 imageSize.x = width;
@@ -28,6 +34,8 @@ define(['barcode_locator', 'config', 'html_utils'],
             sinon.stub(inputStream, "setHeight", function(height) {
                 imageSize.y = height;
             });
+            sinon.stub(inputStream, "setTopRight");
+            sinon.stub(inputStream, "setCanvasSize");
         });
 
         afterEach(function() {
@@ -61,5 +69,63 @@ define(['barcode_locator', 'config', 'html_utils'],
             expect(inputStream.getHeight()).to.be.equal(expected.y);
             expect(inputStream.getWidth()).to.be.equal(expected.x);
         });
+
+        it("should take the defined area into account", function() {
+            var expectedSize = {
+                    x: 420,
+                    y: 315
+                },
+                expectedTopRight = {
+                    x: 115,
+                    y: 52
+                },
+                expectedCanvasSize = {
+                    x: 640,
+                    y: 480
+                };
+
+            streamConfig.area = {
+                top: "11%",
+                right: "15%",
+                bottom: "20%",
+                left: "18%"
+            };
+
+            config.locator.halfSample = false;
+            BarcodeLocator.checkImageConstraints(inputStream, config.locator);
+            expect(inputStream.getHeight()).to.be.equal(expectedSize.y);
+            expect(inputStream.getWidth()).to.be.equal(expectedSize.x);
+            expect(inputStream.setTopRight.getCall(0).args[0]).to.deep.equal(expectedTopRight);
+            expect(inputStream.setCanvasSize.getCall(0).args[0]).to.deep.equal(expectedCanvasSize);
+        });
+
+        it("should return the original size if set to full image", function() {
+            var expectedSize = {
+                    x: 640,
+                    y: 480
+                },
+                expectedTopRight = {
+                    x: 0,
+                    y: 0
+                },
+                expectedCanvasSize = {
+                    x: 640,
+                    y: 480
+                };
+
+            streamConfig.area = {
+                top: "0%",
+                right: "0%",
+                bottom: "0%",
+                left: "0%"
+            };
+
+            config.locator.halfSample = false;
+            BarcodeLocator.checkImageConstraints(inputStream, config.locator);
+            expect(inputStream.getHeight()).to.be.equal(expectedSize.y);
+            expect(inputStream.getWidth()).to.be.equal(expectedSize.x);
+            expect(inputStream.setTopRight.getCall(0).args[0]).to.deep.equal(expectedTopRight);
+            expect(inputStream.setCanvasSize.getCall(0).args[0]).to.deep.equal(expectedCanvasSize);
+        });
     });
 });

spec/cv_utils.spec.js

@@ -24,4 +24,122 @@ define(['cv_utils'], function(CVUtils){
             expect(patchSize).to.be.deep.equal(expected);
         });
     });
+
+    describe('_parseCSSDimensionValues', function() {
+        it("should convert a percentual value correctly", function() {
+            var expected = {
+                    value: 10,
+                    unit: "%"
+                },
+                result = CVUtils._parseCSSDimensionValues("10%");
+
+            expect(result).to.be.deep.equal(expected);
+        });
+
+        it("should convert a 0% value correctly", function() {
+            var expected = {
+                    value: 100,
+                    unit: "%"
+                },
+                result = CVUtils._parseCSSDimensionValues("100%");
+
+            expect(result).to.be.deep.equal(expected);
+        });
+
+        it("should convert a 100% value correctly", function() {
+            var expected = {
+                    value: 0,
+                    unit: "%"
+                },
+                result = CVUtils._parseCSSDimensionValues("0%");
+
+            expect(result).to.be.deep.equal(expected);
+        });
+
+        it("should convert a pixel value to percentage", function() {
+            var expected = {
+                    value: 26.3,
+                    unit: "%"
+                },
+                result = CVUtils._parseCSSDimensionValues("26.3px");
+
+            console.log(result);
+            expect(result).to.be.deep.equal(expected);
+        });
+    });
+
+    describe("_dimensionsConverters", function(){
+        var context;
+
+        beforeEach(function() {
+            context = {
+                width: 640,
+                height: 480
+            };
+        });
+
+        it("should convert a top-value correclty", function() {
+            var expected = 48,
+                result = CVUtils._dimensionsConverters.top({value: 10, unit: "%"}, context);
+
+            expect(result).to.be.equal(expected);
+        });
+
+        it("should convert a right-value correclty", function() {
+            var expected = 640 - 128,
+                result = CVUtils._dimensionsConverters.right({value: 20, unit: "%"}, context);
+
+            expect(result).to.be.equal(expected);
+        });
+
+        it("should convert a bottom-value correclty", function() {
+            var expected = 480 - 77,
+                result = CVUtils._dimensionsConverters.bottom({value: 16, unit: "%"}, context);
+
+            expect(result).to.be.equal(expected);
+        });
+
+        it("should convert a left-value correclty", function() {
+            var expected = 57,
+                result = CVUtils._dimensionsConverters.left({value: 9, unit: "%"}, context);
+
+            expect(result).to.be.equal(expected);
+        });
+    });
+
+    describe("computeImageArea", function() {
+        it("should calculate an image-area", function() {
+            var expected = {
+                    sx: 115,
+                    sy: 48,
+                    sw: 429,
+                    sh: 336
+                },
+                result = CVUtils.computeImageArea(640, 480, {
+                    top: "10%",
+                    right: "15%",
+                    bottom: "20%",
+                    left: "18%"
+                });
+
+            expect(result).to.be.deep.equal(expected);
+        });
+
+        it("should calculate full image-area", function() {
+            var expected = {
+                    sx: 0,
+                    sy: 0,
+                    sw: 640,
+                    sh: 480
+                },
+                result = CVUtils.computeImageArea(640, 480, {
+                    top: "0%",
+                    right: "0%",
+                    bottom: "0%",
+                    left: "0%"
+                });
+
+            expect(result).to.be.deep.equal(expected);
+        });
+    });
 });