ng-zenduit 1.0.0

package/esm2020/lib/doc-scanner/zendu-doc-scanner.component.mjs

@@ -0,0 +1,628 @@
+import { fabric } from 'fabric';
+import { Component, Input, ViewChild, Output, EventEmitter, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/opencv.service";
+import * as i2 from "@angular/common";
+export class ZenduDocScanner {
+    constructor(_opencv) {
+        this._opencv = _opencv;
+        this.src = '';
+        this.width = 0;
+        this.height = 0;
+        this.isScanStart = false;
+        this.canAddText = false;
+        this.canDoodle = false;
+        this.currentStateIndex = -1;
+        this.canvasStates = [];
+        this.isResize = false;
+        this.isRedoing = false;
+        this.isUndoing = false;
+        this.extracted = new EventEmitter();
+        this.cornersChanged = new EventEmitter();
+        this.canAddTextOrDoole = new EventEmitter();
+        this.canRedoOrUndo = new EventEmitter();
+        this.screenPoints = [];
+        this._scaleFactor = 1;
+        this._controls = [];
+        this.selectedColor = '#121212';
+        this.isScaned = false;
+        this.textAdded = false;
+        this.icons = {
+            cross: new Image(),
+            rotate: new Image(),
+            expand: new Image(),
+        };
+        this.Image = {
+            height: 0,
+            width: 0,
+        };
+        this.borderWidth = 5;
+        this.colors = [
+            { hexCode: '#FFFFFF', selected: false },
+            { hexCode: '#121212', selected: false },
+            { hexCode: '#2188D9', selected: false },
+            { hexCode: '#DC3E33', selected: false },
+            { hexCode: '#219653', selected: false },
+            { hexCode: '#F1B10B', selected: false },
+            { hexCode: '#00F0FF', selected: false },
+        ];
+    }
+    set done(completed) {
+        console.log('mark as completed', completed);
+        if (completed) {
+            this.completeScan(completed);
+        }
+    }
+    ngAfterViewInit() {
+        this.icons.cross.src = 'assets/ng-zenduit/icons/cross.svg';
+        this.icons.rotate.src = 'assets/ng-zenduit/icons/rotate.svg';
+        this.icons.expand.src = 'assets/ng-zenduit/icons/expand.svg';
+        setTimeout(async () => {
+            await this.init();
+            // Add an event listener for canvas edits
+        }, 1);
+    }
+    onCanvasEdit() {
+        let objects = this._canvas.getObjects();
+        if (objects && objects.length)
+            this._canvas._activeObject = objects[objects.length - 1];
+        if (!this.isScanStart && !this.isRedoing && !this.isUndoing) {
+            this.canRedoOrUndo.emit({
+                canUndo: this.currentStateIndex >= 0 ? true : false,
+                canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,
+            });
+            this.saveCanvasState();
+        }
+    }
+    ngOnChanges(changes) {
+        // When src changes
+        if (changes['src'] && this._canvas) {
+            this.build();
+        }
+        //When user start scan
+        if (changes['isScanStart'] && changes['isScanStart'].currentValue) {
+            if (this.src && this._canvas && this.isScanStart) {
+                this.addPointsTodoc();
+                this.canDoodle = false;
+                this._canvas.isDrawingMode = false;
+                this.isScaned = true;
+                this._canvas.selection = false;
+                this.textAdded = false;
+            }
+        }
+        // When user wants to draw
+        if (changes['canDoodle'] &&
+            changes['canDoodle'].currentValue &&
+            this._canvas) {
+            if (this.canDoodle) {
+                this._canvas.isDrawingMode = this.canDoodle;
+                this._canvas.freeDrawingBrush = this.canDoodle
+                    ? new fabric.PencilBrush(this._canvas)
+                    : null;
+                this._canvas.freeDrawingBrush.width = 10;
+                this._canvas.freeDrawingBrush.color = this.selectedColor;
+                this._canvas.selection = false;
+                this.isScanStart = false;
+                this.textAdded = false;
+                this._canvas.renderAll();
+            }
+        }
+        // When user wants to add text
+        if (changes['canAddText'] &&
+            changes['canAddText'].currentValue &&
+            this.canAddText) {
+            this.canDoodle = false;
+            this._canvas.isDrawingMode = false;
+            this.isScanStart = false;
+        }
+        if (changes['isUndoing'] && changes['isUndoing'].currentValue)
+            this.undo();
+        if (changes['isRedoing'] && changes['isRedoing'].currentValue)
+            this.redo();
+    }
+    // To change the color of brush or text
+    chngClrTextOrBrush(color, changeFor) {
+        this.selectedColor = color;
+        this.colors.map((clr, index) => {
+            this.colors[index] = { ...this.colors[index], selected: false };
+            if (this.colors[index].hexCode === color) {
+                this.colors[index] = { ...this.colors[index], selected: true };
+            }
+        });
+        if (changeFor === 'text') {
+            const activeObject = this._canvas.getActiveObject();
+            if (activeObject && activeObject.type === 'i-text') {
+                // Check if an active text object is selected
+                activeObject.set('fill', this.selectedColor); // Update the fill color
+                this._canvas.renderAll(); // Render the canvas to see the changes
+            }
+            this._canvas.renderAll();
+            // this.onCanvasEdit();
+        }
+        else {
+            this._canvas.freeDrawingBrush.color = color;
+        }
+        this.selectedColor = color;
+    }
+    async addPointsTodoc() {
+        const corners = await this._opencv.getPaperCorners(this._canvas.toDataURL({
+            format: 'jpeg',
+            quality: 1,
+        }), this.Image.height, this.Image.width);
+        if (corners) {
+            this.screenPoints = [
+                corners.topLeftCorner,
+                corners.topRightCorner,
+                corners.bottomRightCorner,
+                corners.bottomLeftCorner,
+            ];
+        }
+        else {
+            console.error(`can't detect document corners`);
+            const width = this._canvas.getWidth() / this._scaleFactor;
+            const height = this._canvas.getHeight() / this._scaleFactor;
+            const offset = 20;
+            this.screenPoints = [
+                { x: offset, y: 0 },
+                { x: width - offset, y: 0 },
+                { x: width - offset, y: height - offset },
+                { x: offset, y: height - offset },
+            ];
+        }
+        // add polygon
+        //
+        this._cornersPg = new fabric.Polygon(this.screenPoints, {
+            stroke: '#2188d9',
+            strokeWidth: 10,
+            selectable: false,
+            fill: 'rgba(33, 136, 217, 0.1)',
+            hasBorders: true,
+            objectCaching: false,
+        });
+        this._canvas.add(this._cornersPg);
+        this.createControls(this._cornersPg);
+    }
+    async init(src) {
+        // Create canvas with new changed src
+        if (src) {
+            this.createCanvas();
+        }
+        else {
+            try {
+                if (!this._canvasElement || !this._canvasElement.nativeElement) {
+                    // canvas is not ready
+                    return;
+                }
+                if (this._canvas) {
+                    // canvas already initalized
+                    return;
+                }
+                this.createCanvas();
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+    async createCanvas() {
+        // documentation: http://fabricjs.com/docs/fabric.Canvas.html
+        let canvas = this._canvasElement.nativeElement;
+        this._canvas = new fabric.Canvas(canvas, {
+            backgroundColor: 'white',
+            selection: false,
+        });
+        const { width, height } = this.getCanvasSize();
+        this._canvas.setWidth(width);
+        this._canvas.setHeight(height);
+        this._canvas.on('object:added', this.onCanvasEdit.bind(this));
+        this._canvas.on('object:modified', this.onCanvasEdit.bind(this));
+        this._canvas.on('mouse:down', this.addTextOnClick.bind(this));
+        this._canvas.on('mouse:move', this.resizeText.bind(this));
+        this._canvas.on('mouse:up', this.stopResizeText.bind(this));
+        if (this.src) {
+            await this.build();
+        }
+    }
+    renderIcon(ctx, left, top, styleOverride, fabricObject, iconName) {
+        var size = 42;
+        var iconBackgroundSize = 50; // Adjust the size as needed
+        ctx.save();
+        // Draw a background circle behind the icon
+        ctx.fillStyle = 'white'; // Set the background color
+        ctx.beginPath();
+        ctx.arc(left, top - 10, iconBackgroundSize / 2, 0, 2 * Math.PI);
+        ctx.fill();
+        var img = this.icons[iconName];
+        img.onload = function () { };
+        ctx.translate(left, top - 10);
+        ctx.rotate(fabric.util.degreesToRadians(fabricObject.angle));
+        ctx.drawImage(img, -size / 2, -size / 2, size, size);
+        ctx.restore();
+    }
+    stopResizeText(event) {
+        if (this.isResize) {
+            this.saveCanvasState();
+            this.isResize = false;
+        }
+    }
+    resizeText(event) {
+        if (this.isResize) {
+            const target = event.target;
+            const deltaY = event.e.clientY - this.initialMouseY;
+            // Limit the scaling factor to prevent excessive resizing
+            const scalingFactor = Math.min(2, Math.max(0.5, 1 + deltaY / 100));
+            // Calculate the new font size based on the original size and scaling factor
+            const newFontSize = this.originalFontSize * scalingFactor;
+            // Set the font size of the text object
+            target.fontSize = newFontSize;
+            // Re-render the canvas to see the live change
+            event.target.canvas.renderAll();
+        }
+    }
+    addTextOnClick(event) {
+        let _text = new fabric.IText('Type your text here', {
+            left: event.pointer.x,
+            top: event.pointer.y,
+            fill: this.selectedColor,
+            fontSize: 50,
+            fontFamily: 'Roboto',
+            selectable: true,
+            fontWeight: 400,
+            borderScaleFactor: 3,
+            borderColor: 'white',
+            backgroundColor: 'transparent',
+            cornerColor: 'white',
+            padding: 42,
+            width: 200, // Set the initial width of the text box
+        });
+        //Custom controls for add text box
+        let customControls = {
+            removeControl: new fabric.Control({
+                x: -0.5,
+                y: -0.5,
+                offsetY: 16,
+                cursorStyle: 'pointer',
+                render: (ctx, left, top, styleOverride, fabricObject) => {
+                    return this.renderIcon(ctx, left, top, styleOverride, fabricObject, 'cross');
+                },
+                mouseUpHandler: (eventData, transform) => {
+                    var target = transform.target;
+                    var canvas = target.canvas;
+                    canvas.remove(target);
+                    canvas.requestRenderAll();
+                    this.saveCanvasState();
+                    return true;
+                },
+            }),
+            rotateControl: new fabric.Control({
+                x: 0.5,
+                y: -0.5,
+                offsetY: 16,
+                cursorStyle: 'pointer',
+                render: (ctx, left, top, styleOverride, fabricObject) => {
+                    return this.renderIcon(ctx, left, top, styleOverride, fabricObject, 'rotate');
+                },
+                mouseUpHandler: (eventData, transform) => {
+                    let fabricObject = transform.target;
+                    const rotationIncrement = 30; // Rotation increment in degrees
+                    fabricObject.set('angle', (fabricObject.angle + rotationIncrement) % 360);
+                    fabricObject.setCoords(); // Update object's coordinates
+                    this.saveCanvasState();
+                    return true;
+                },
+            }),
+            expantControl: new fabric.Control({
+                x: 0.5,
+                y: 0.5,
+                offsetY: 16,
+                cursorStyle: 'grab',
+                render: (ctx, left, top, styleOverride, fabricObject) => {
+                    return this.renderIcon(ctx, left, top, styleOverride, fabricObject, 'expand');
+                },
+            }),
+        };
+        if (event.transform && event.transform.action === 'scale') {
+            this.isResize = true;
+            this.initialMouseY = event.e.clientY;
+            this.originalFontSize = event.target.fontSize;
+        }
+        if (!this.textAdded &&
+            !this.canDoodle &&
+            !this.isScanStart &&
+            this.canAddText) {
+            _text.controls = customControls;
+            this._canvas.add(_text);
+            this._canvas.renderAll();
+            this.textAdded = true;
+        }
+    }
+    // Function to save the canvas state
+    saveCanvasState() {
+        const state = JSON.stringify(this._canvas.toJSON());
+        // const state = this._canvas.getObjects()[this._canvas.getObjects.length - 1]
+        if (this.currentStateIndex < this.canvasStates.length - 1) {
+            this.canvasStates.length = this.currentStateIndex + 1; // Remove future states
+        }
+        let activeObj = this._canvas.getActiveObject();
+        if (activeObj && activeObj.type === 'path') {
+            // set remove border and controls for drawing
+            activeObj.set({
+                hasControls: false,
+                selectable: false,
+                hasBorders: false,
+            });
+        }
+        const customControl = activeObj && activeObj.controls ? activeObj.controls : null;
+        this.canvasStates.push({ state, customControl });
+        this.currentStateIndex++;
+    }
+    redo() {
+        this.isRedoing = true;
+        if (this.currentStateIndex < this.canvasStates.length - 1) {
+            this.currentStateIndex++;
+            const nextState = this.canvasStates[this.currentStateIndex];
+            this.canRedoOrUndo.emit({
+                canUndo: this.currentStateIndex > 0 ? true : false,
+                canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,
+            });
+            this._canvas.loadFromJSON(nextState.state, () => {
+                let activeObject = this._canvas.getActiveObject();
+                this._canvas.getObjects().forEach((obj) => {
+                    if (obj !== activeObject) {
+                        obj.evented = false;
+                    }
+                });
+                if (activeObject && activeObject.type !== 'path') {
+                    activeObject.controls =
+                        nextState && nextState.customControl
+                            ? nextState.customControl
+                            : null;
+                    activeObject.set({
+                        padding: 42,
+                        borderScaleFactor: 3,
+                        borderColor: 'white',
+                    });
+                    this.textAdded = true;
+                    this.canAddTextOrDoole.emit({ key: 'doodle', value: false });
+                    this.canAddTextOrDoole.emit({ key: 'text', value: true });
+                }
+                else {
+                    activeObject.set({
+                        hasControls: false,
+                        selectable: false,
+                        hasBorders: false,
+                    });
+                    this.canAddTextOrDoole.emit({ key: 'text', value: false });
+                    this.canAddTextOrDoole.emit({ key: 'doodle', value: true });
+                    this._canvas.selection = false;
+                }
+                this._canvas.renderAll();
+            });
+        }
+    }
+    undo() {
+        this.isUndoing = true;
+        if (this.currentStateIndex > 0) {
+            this.currentStateIndex--;
+            const previousState = this.canvasStates[this.currentStateIndex];
+            this.canRedoOrUndo.emit({
+                canUndo: this.currentStateIndex > 0 ? true : false,
+                canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,
+            });
+            this._canvas.loadFromJSON(previousState.state, () => {
+                let activeObject = this._canvas.getActiveObject();
+                if (activeObject) {
+                    if (activeObject.type !== 'path') {
+                        activeObject.set({
+                            padding: 42,
+                            borderScaleFactor: 3,
+                            borderColor: 'white',
+                        });
+                        this._canvas.isDrawingMode = false;
+                        this._canvas.freeDrawingBrush = null;
+                        this.textAdded = true;
+                        this.canAddTextOrDoole.emit({ key: 'doodle', value: false });
+                        this.canAddTextOrDoole.emit({ key: 'text', value: true });
+                    }
+                    else {
+                        activeObject.set({
+                            hasControls: false,
+                            hasBorders: false,
+                        });
+                        this._canvas.selection = false;
+                        this.canAddTextOrDoole.emit({ key: 'text', value: false });
+                        this.canAddTextOrDoole.emit({ key: 'doodle', value: true });
+                    }
+                    this._canvas.getActiveObject().controls =
+                        previousState && previousState.customControl
+                            ? previousState.customControl
+                            : null;
+                }
+                this._canvas.getObjects().forEach((obj) => {
+                    if (obj !== activeObject) {
+                        obj.evented = false;
+                    }
+                });
+                this._canvas.renderAll();
+            });
+        }
+    }
+    getCanvasSize() {
+        const img = new Image();
+        img.src = this.src;
+        const box = this._component.nativeElement.getBoundingClientRect();
+        const width = this.width || box.width || 1;
+        const height = this.height || box.height || 1;
+        return { width, height };
+    }
+    /**
+     * recognize paper corners
+     */
+    async build() {
+        if (!this.src || !this._canvas) {
+            return;
+        }
+        const bg = await this.loadBackgroundImage(this.src);
+        // Remove all the existing objects before add the new image to background
+        this._canvas.clear();
+        const imgSize = bg.getOriginalSize();
+        this.Image = {
+            height: imgSize.height * this._scaleFactor,
+            width: imgSize.width * this._scaleFactor,
+        };
+        const scaleX = this._canvas.width / imgSize.width;
+        const scaleY = this._canvas.height / imgSize.height;
+        this._scaleFactor = Math.min(scaleY, scaleX);
+        this._canvas.setDimensions({
+            width: imgSize.width,
+            height: imgSize.height,
+        }, {
+            backstoreOnly: true,
+        });
+        this._canvas.setBackgroundImage(bg, () => {
+            this._canvas.renderAll();
+        });
+        this.saveCanvasState();
+        this._canvas.renderAll();
+    }
+    createControls(polygon) {
+        // remove previous controls
+        if (this._controls.length) {
+            this._canvas.remove(...this._controls);
+            this._controls = [];
+        }
+        if (polygon) {
+            for (const [index, point] of polygon.points.entries()) {
+                const circle = this.createControl(index, polygon);
+                this._controls.push(circle);
+                this._canvas.add(circle);
+            }
+        }
+    }
+    createControl(index, polygon) {
+        const point = polygon.points[index];
+        const circle = new fabric.Circle({
+            left: point.x,
+            top: point.y,
+            originX: 'center',
+            originY: 'center',
+            fill: '#2188d9',
+            radius: 20,
+            hasRotatingPoint: false,
+            hasBorders: false,
+            hasControls: false,
+            objectCaching: false,
+        });
+        circle.on('moving', (evt) => {
+            if (evt.pointer) {
+                polygon.points[index] = new fabric.Point(evt.pointer.x, evt.pointer.y);
+                polygon.dirty = true;
+            }
+        });
+        circle.on('mouseup', (evt) => {
+            this.cornersChanged.emit();
+            this.screenPoints[index] = polygon.points[index];
+        });
+        return circle;
+    }
+    loadBackgroundImage(src) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                let fabImage = new fabric.Image(img);
+                resolve(fabImage);
+            };
+            img.src = src;
+        });
+    }
+    async completeScan(completed) {
+        if (!completed) {
+            return;
+        }
+        console.log(`complete scan & extract paper`);
+        if (!this._cornersPg) {
+            console.error(`Corner line is not available`);
+        }
+        if (this._cornersPg) {
+            this._canvas.remove(this._cornersPg);
+            this._canvas.remove(...this._controls);
+            this._canvas.renderAll();
+        }
+        let output;
+        if (this.isScaned) {
+            output = await this._opencv.extractPaper({
+                src: this._canvas.toDataURL({ quality: 1 }),
+                corners: {
+                    topLeftCorner: this.screenPoints[0],
+                    topRightCorner: this.screenPoints[1],
+                    bottomRightCorner: this.screenPoints[2],
+                    bottomLeftCorner: this.screenPoints[3],
+                },
+                height: this._canvas.height,
+                width: this._canvas.width,
+            });
+            this._canvas.remove(...this._canvas.getObjects());
+            this.isScaned = false;
+        }
+        else {
+            output = this._canvas.toCanvasElement();
+        }
+        this.currentStateIndex = null;
+        this.canvasStates = [];
+        this.canRedoOrUndo.emit({
+            canUndo: this.currentStateIndex > 0 ? true : false,
+            canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,
+        });
+        this.extracted.emit(output);
+        this.cleanupCanvas();
+    }
+    cleanupCanvas() {
+        this._canvas.getObjects().forEach((obj) => (obj.evented = false));
+        this._canvas.selection = false;
+        this._canvas.isDrawingMode = false;
+        this.canDoodle = false;
+        this.isScanStart = false;
+        this.canAddText = false;
+        this.textAdded = false;
+        this._canvas.renderAll();
+    }
+}
+ZenduDocScanner.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduDocScanner, deps: [{ token: i1.OpenCVService }], target: i0.ɵɵFactoryTarget.Component });
+ZenduDocScanner.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ZenduDocScanner, selector: "zen-doc-scanner", inputs: { src: "src", width: "width", height: "height", isScanStart: "isScanStart", canAddText: "canAddText", canDoodle: "canDoodle", isRedoing: "isRedoing", isUndoing: "isUndoing", done: "done" }, outputs: { extracted: "extracted", cornersChanged: "cornersChanged", canAddTextOrDoole: "canAddTextOrDoole", canRedoOrUndo: "canRedoOrUndo" }, viewQueries: [{ propertyName: "_canvasElement", first: true, predicate: ["drawCanas"], descendants: true }, { propertyName: "_component", first: true, predicate: ["componentWrapper"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #componentWrapper\n     class=\"component\">\n    <canvas #drawCanas></canvas>\n  <div class=\"colors-container\" *ngIf=\"canDoodle || canAddText\">\n    <div class=\"colors\" *ngFor=\"let color of colors\" [ngStyle]=\"{'background': color.hexCode, 'border':color.selected ? '1.6px solid white' : 'none'}\" (click)=\"chngClrTextOrBrush(color.hexCode, canAddText ? 'text': 'doodle')\"></div>\n  </div>\n</div>\n", styles: [".component{width:100%;height:100%}.colors-container{display:flex;height:20px;gap:16px;padding:8px 62px;justify-content:space-between;background:#262626}.colors-container .colors{width:20px;height:20px;border-radius:50%}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduDocScanner, decorators: [{
+            type: Component,
+            args: [{ selector: 'zen-doc-scanner', template: "<div #componentWrapper\n     class=\"component\">\n    <canvas #drawCanas></canvas>\n  <div class=\"colors-container\" *ngIf=\"canDoodle || canAddText\">\n    <div class=\"colors\" *ngFor=\"let color of colors\" [ngStyle]=\"{'background': color.hexCode, 'border':color.selected ? '1.6px solid white' : 'none'}\" (click)=\"chngClrTextOrBrush(color.hexCode, canAddText ? 'text': 'doodle')\"></div>\n  </div>\n</div>\n", styles: [".component{width:100%;height:100%}.colors-container{display:flex;height:20px;gap:16px;padding:8px 62px;justify-content:space-between;background:#262626}.colors-container .colors{width:20px;height:20px;border-radius:50%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.OpenCVService }]; }, propDecorators: { _canvasElement: [{
+                type: ViewChild,
+                args: ['drawCanas']
+            }], _component: [{
+                type: ViewChild,
+                args: ['componentWrapper']
+            }], src: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], isScanStart: [{
+                type: Input
+            }], canAddText: [{
+                type: Input
+            }], canDoodle: [{
+                type: Input
+            }], isRedoing: [{
+                type: Input
+            }], isUndoing: [{
+                type: Input
+            }], done: [{
+                type: Input
+            }], extracted: [{
+                type: Output
+            }], cornersChanged: [{
+                type: Output
+            }], canAddTextOrDoole: [{
+                type: Output
+            }], canRedoOrUndo: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zendu-doc-scanner.component.js","sourceRoot":"","sources":["../../../../../projects/ng-zenduit/src/lib/doc-scanner/zendu-doc-scanner.component.ts","../../../../../projects/ng-zenduit/src/lib/doc-scanner/zendu-doc-scanner.component.html"],"names":[],"mappings":"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","sourcesContent":["import { fabric } from 'fabric';\nimport {\n  Component,\n  ElementRef,\n  Input,\n  AfterViewInit,\n  ViewChild,\n  OnChanges,\n  Output,\n  EventEmitter,\n  SimpleChanges,\n} from '@angular/core';\nimport { OpenCVService } from '../services/opencv.service';\nimport { IText } from 'fabric/fabric-impl';\n\n@Component({\n  selector: 'zen-doc-scanner',\n  templateUrl: './zendu-doc-scanner.component.html',\n  styleUrls: ['./zendu-doc-scanner.component.scss'],\n})\nexport class ZenduDocScanner implements AfterViewInit, OnChanges {\n  @ViewChild('drawCanas') _canvasElement!: ElementRef<HTMLCanvasElement>;\n\n  @ViewChild('componentWrapper') _component!: ElementRef<HTMLDivElement>;\n\n  @Input() src = '';\n\n  @Input() width = 0;\n\n  @Input() height = 0;\n\n  @Input() isScanStart: boolean = false;\n\n  @Input() canAddText: boolean = false;\n\n  @Input() canDoodle: boolean = false;\n\n  currentStateIndex: number = -1;\n\n  canvasStates: { state: string; customControl: any }[] = [];\n\n  isResize: boolean = false;\n  initialMouseY: number;\n  originalFontSize: number;\n\n  @Input() isRedoing: boolean = false;\n  @Input() isUndoing: boolean = false;\n  @Input() set done(completed: boolean) {\n    console.log('mark as completed',completed);\n    if (completed) {\n      this.completeScan(completed);\n    }\n  }\n\n  @Output() extracted = new EventEmitter<HTMLCanvasElement>();\n\n  @Output() cornersChanged = new EventEmitter<void>();\n\n  @Output() canAddTextOrDoole = new EventEmitter<{}>();\n\n  @Output() canRedoOrUndo = new EventEmitter<{\n    canRedo: boolean;\n    canUndo: boolean;\n  }>();\n\n  private screenPoints: { x: number; y: number }[] = [];\n\n  private _canvas!: fabric.Canvas;\n\n  private _cornersPg!: fabric.Polygon;\n\n  private _scaleFactor = 1;\n\n  private _controls: fabric.Circle[] = [];\n\n  selectedColor: string = '#121212';\n\n  isScaned: boolean = false;\n\n  textAdded: boolean = false;\n\n   icons = {\n    cross: new Image(),\n    rotate: new Image(),\n    expand: new Image(),\n  };\n  private Image = {\n    height: 0,\n    width: 0,\n  };\n  borderWidth: number = 5;\n  colors = [\n    { hexCode: '#FFFFFF', selected: false },\n    { hexCode: '#121212', selected: false },\n    { hexCode: '#2188D9', selected: false },\n    { hexCode: '#DC3E33', selected: false },\n    { hexCode: '#219653', selected: false },\n    { hexCode: '#F1B10B', selected: false },\n    { hexCode: '#00F0FF', selected: false },\n  ];\n  resizeIcon: HTMLElement;\n  rotateIcon: HTMLElement;\n  removeIcon: HTMLElement;\n  constructor(private _opencv: OpenCVService) {}\n\n  public ngAfterViewInit() {\n    this.icons.cross.src = 'assets/ng-zenduit/icons/cross.svg';\n    this.icons.rotate.src = 'assets/ng-zenduit/icons/rotate.svg';\n    this.icons.expand.src= 'assets/ng-zenduit/icons/expand.svg';\n    setTimeout(async () => {\n      await this.init();\n      // Add an event listener for canvas edits\n    }, 1);\n  }\n\n  public onCanvasEdit() {\n    let objects = this._canvas.getObjects();\n    if (objects && objects.length)\n      this._canvas._activeObject = objects[objects.length - 1];\n    if (!this.isScanStart && !this.isRedoing && !this.isUndoing) {\n      this.canRedoOrUndo.emit({\n        canUndo: this.currentStateIndex >= 0 ? true : false,\n        canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,\n      });\n      this.saveCanvasState();\n    }\n  }\n  public ngOnChanges(changes: SimpleChanges) {\n\n    // When src changes\n    if (changes['src'] && this._canvas) {\n      this.build();\n    }\n    //When user start scan\n    if (changes['isScanStart'] && changes['isScanStart'].currentValue) {\n      if (this.src && this._canvas && this.isScanStart) {\n        this.addPointsTodoc();\n        this.canDoodle = false;\n        this._canvas.isDrawingMode = false;\n        this.isScaned = true;\n        this._canvas.selection = false;\n        this.textAdded = false;\n      }\n    }\n    // When user wants to draw\n    if (\n      changes['canDoodle'] &&\n      changes['canDoodle'].currentValue &&\n      this._canvas\n    ) {\n      if (this.canDoodle) {\n        this._canvas.isDrawingMode = this.canDoodle;\n        this._canvas.freeDrawingBrush = this.canDoodle\n          ? new fabric.PencilBrush(this._canvas)\n          : null;\n        this._canvas.freeDrawingBrush.width = 10;\n        this._canvas.freeDrawingBrush.color = this.selectedColor;\n        this._canvas.selection = false;\n        this.isScanStart = false;\n        this.textAdded = false;\n        this._canvas.renderAll();\n      }\n    }\n    // When user wants to add text\n    if (\n      changes['canAddText'] &&\n      changes['canAddText'].currentValue &&\n      this.canAddText\n    ) {\n      this.canDoodle = false;\n      this._canvas.isDrawingMode = false;\n      this.isScanStart = false;\n    }\n    if (changes['isUndoing'] && changes['isUndoing'].currentValue) this.undo();\n    if (changes['isRedoing'] && changes['isRedoing'].currentValue) this.redo();\n  }\n  // To change the color of brush or text\n  chngClrTextOrBrush(color: string, changeFor: string) {\n    this.selectedColor = color;\n    this.colors.map((clr, index) => {\n      this.colors[index] = { ...this.colors[index], selected: false };\n      if (this.colors[index].hexCode === color) {\n        this.colors[index] = { ...this.colors[index], selected: true };\n      }\n    });\n    if (changeFor === 'text') {\n      const activeObject = this._canvas.getActiveObject();\n      if (activeObject && activeObject.type === 'i-text') {\n        // Check if an active text object is selected\n        activeObject.set('fill', this.selectedColor); // Update the fill color\n        this._canvas.renderAll(); // Render the canvas to see the changes\n      }\n      this._canvas.renderAll();\n      // this.onCanvasEdit();\n    } else {\n      this._canvas.freeDrawingBrush.color = color;\n    }\n    this.selectedColor = color;\n  }\n  async addPointsTodoc() {\n    const corners = await this._opencv.getPaperCorners(\n      this._canvas.toDataURL({\n        format: 'jpeg',\n        quality: 1,\n      }),\n      this.Image.height,\n      this.Image.width\n    );\n    if (corners) {\n      this.screenPoints = [\n        corners.topLeftCorner,\n        corners.topRightCorner,\n        corners.bottomRightCorner,\n        corners.bottomLeftCorner,\n      ];\n    } else {\n      console.error(`can't detect document corners`);\n      const width = this._canvas.getWidth() / this._scaleFactor;\n      const height = this._canvas.getHeight() / this._scaleFactor;\n      const offset = 20;\n      this.screenPoints = [\n        { x: offset, y: 0 },\n        { x: width - offset, y: 0 },\n        { x: width - offset, y: height - offset },\n        { x: offset, y: height - offset },\n      ];\n    }\n\n    // add polygon\n    //\n    this._cornersPg = new fabric.Polygon(this.screenPoints, {\n      stroke: '#2188d9',\n      strokeWidth: 10,\n      selectable: false,\n      fill: 'rgba(33, 136, 217, 0.1)',\n      hasBorders: true,\n      objectCaching: false,\n    });\n    this._canvas.add(this._cornersPg);\n    this.createControls(this._cornersPg);\n  }\n\n  private async init(src?: string) {\n    // Create canvas with new changed src\n    if (src) {\n      this.createCanvas();\n    } else {\n      try {\n        if (!this._canvasElement || !this._canvasElement.nativeElement) {\n          // canvas is not ready\n          return;\n        }\n\n        if (this._canvas) {\n          // canvas already initalized\n          return;\n        }\n        this.createCanvas();\n      } catch (err) {\n        console.error(err);\n      }\n    }\n  }\n\n  async createCanvas() {\n    // documentation: http://fabricjs.com/docs/fabric.Canvas.html\n    let canvas = this._canvasElement.nativeElement;\n    this._canvas = new fabric.Canvas(canvas, {\n      backgroundColor: 'white',\n      selection: false,\n    });\n    const { width, height } = this.getCanvasSize();\n    this._canvas.setWidth(width);\n    this._canvas.setHeight(height);\n    this._canvas.on('object:added', this.onCanvasEdit.bind(this));\n    this._canvas.on('object:modified', this.onCanvasEdit.bind(this));\n    this._canvas.on('mouse:down', this.addTextOnClick.bind(this));\n    this._canvas.on('mouse:move', this.resizeText.bind(this));\n    this._canvas.on('mouse:up', this.stopResizeText.bind(this));\n    if (this.src) {\n      await this.build();\n    }\n  }\n\n  renderIcon(\n    ctx: CanvasRenderingContext2D,\n    left: number,\n    top: number,\n    styleOverride,\n    fabricObject: fabric.Object,\n    iconName: string\n  ) {\n    var size = 42;\n    var iconBackgroundSize = 50; // Adjust the size as needed\n    ctx.save();\n\n    // Draw a background circle behind the icon\n    ctx.fillStyle = 'white'; // Set the background color\n    ctx.beginPath();\n    ctx.arc(left, top - 10, iconBackgroundSize / 2, 0, 2 * Math.PI);\n    ctx.fill();\n\n    var img = this.icons[iconName];\n    img.onload = function (){}\n    ctx.translate(left, top - 10);\n    ctx.rotate(fabric.util.degreesToRadians(fabricObject.angle));\n    ctx.drawImage(img, -size / 2, -size / 2, size, size);\n    ctx.restore();\n  }\n\n  stopResizeText(event:any) {\n    if(this.isResize){\n      this.saveCanvasState()\n      this.isResize = false;\n    }\n  }\n  resizeText(event: any) {\n    if (this.isResize) {\n      const target = event.target;\n      const deltaY = event.e.clientY - this.initialMouseY;\n\n      // Limit the scaling factor to prevent excessive resizing\n      const scalingFactor = Math.min(2, Math.max(0.5, 1 + deltaY / 100));\n\n      // Calculate the new font size based on the original size and scaling factor\n      const newFontSize = this.originalFontSize * scalingFactor;\n\n      // Set the font size of the text object\n      target.fontSize = newFontSize;\n\n      // Re-render the canvas to see the live change\n      event.target.canvas.renderAll();\n    }\n  }\n  addTextOnClick(event: any) {\n    let _text: IText = new fabric.IText('Type your text here', {\n      left: event.pointer.x,\n      top: event.pointer.y,\n      fill: this.selectedColor,\n      fontSize: 50,\n      fontFamily: 'Roboto',\n      selectable: true,\n      fontWeight: 400,\n      borderScaleFactor: 3,\n      borderColor: 'white',\n      backgroundColor: 'transparent', // Set background color of the text box\n      cornerColor: 'white', // Set corner (resize handle) color of the text box\n      padding: 42, // Set padding inside the text box\n      width: 200, // Set the initial width of the text box\n    });\n      //Custom controls for add text box\n  let customControls = {\n    removeControl: new fabric.Control({\n      x: -0.5,\n      y: -0.5,\n      offsetY: 16,\n      cursorStyle: 'pointer',\n      render: (ctx, left, top, styleOverride, fabricObject) => {\n        return this.renderIcon(\n          ctx,\n          left,\n          top,\n          styleOverride,\n          fabricObject,\n          'cross'\n        );\n      },\n      mouseUpHandler: (eventData, transform) => {\n        var target = transform.target;\n        var canvas = target.canvas;\n        canvas.remove(target);\n        canvas.requestRenderAll();\n        this.saveCanvasState();\n        return true;\n      },\n    }),\n\n    rotateControl: new fabric.Control({\n      x: 0.5,\n      y: -0.5,\n      offsetY: 16,\n      cursorStyle: 'pointer',\n      render: (ctx, left, top, styleOverride, fabricObject) => {\n        return this.renderIcon(\n          ctx,\n          left,\n          top,\n          styleOverride,\n          fabricObject,\n          'rotate'\n        );\n      },\n      mouseUpHandler: (eventData, transform) => {\n        let fabricObject = transform.target;\n        const rotationIncrement = 30; // Rotation increment in degrees\n        fabricObject.set(\n          'angle',\n          (fabricObject.angle + rotationIncrement) % 360\n        );\n        fabricObject.setCoords(); // Update object's coordinates\n        this.saveCanvasState();\n        return true;\n      },\n    }),\n\n    expantControl: new fabric.Control({\n      x: 0.5,\n      y: 0.5,\n      offsetY: 16,\n      cursorStyle: 'grab',\n      render: (ctx, left, top, styleOverride, fabricObject) => {\n        return this.renderIcon(\n          ctx,\n          left,\n          top,\n          styleOverride,\n          fabricObject,\n          'expand'\n        );\n      },\n    }),\n  };\n    if (event.transform && event.transform.action === 'scale') {\n      this.isResize = true;\n      this.initialMouseY = event.e.clientY;\n      this.originalFontSize = event.target.fontSize;\n    }\n    if (\n      !this.textAdded &&\n      !this.canDoodle &&\n      !this.isScanStart &&\n      this.canAddText\n    ) {\n      _text.controls = customControls;\n      this._canvas.add(_text);\n      this._canvas.renderAll();\n      this.textAdded = true;\n    }\n  }\n\n  // Function to save the canvas state\n  saveCanvasState() {\n    const state = JSON.stringify(this._canvas.toJSON());\n    // const state = this._canvas.getObjects()[this._canvas.getObjects.length - 1]\n    if (this.currentStateIndex < this.canvasStates.length - 1) {\n      this.canvasStates.length = this.currentStateIndex + 1; // Remove future states\n    }\n    let activeObj = this._canvas.getActiveObject();\n\n    if (activeObj && activeObj.type === 'path'){\n\n      // set remove border and controls for drawing\n      activeObj.set({\n        hasControls: false,\n        selectable: false,\n        hasBorders: false,\n      });\n    }\n    const customControl =\n      activeObj && activeObj.controls ? activeObj.controls : null;\n    this.canvasStates.push({ state, customControl });\n    this.currentStateIndex++;\n  }\n  public redo() {\n    this.isRedoing = true;\n    if (this.currentStateIndex < this.canvasStates.length - 1) {\n      this.currentStateIndex++;\n      const nextState = this.canvasStates[this.currentStateIndex];\n      this.canRedoOrUndo.emit({\n        canUndo: this.currentStateIndex > 0 ? true : false,\n        canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,\n      });\n      this._canvas.loadFromJSON(nextState.state, () => {\n        let activeObject = this._canvas.getActiveObject();\n        this._canvas.getObjects().forEach((obj) => {\n          if (obj !== activeObject) {\n            obj.evented = false;\n          }\n        });\n        if (activeObject && activeObject.type !== 'path') {\n          activeObject.controls =\n            nextState && nextState.customControl\n              ? nextState.customControl\n              : null;\n          activeObject.set({\n            padding: 42,\n            borderScaleFactor: 3,\n            borderColor: 'white',\n          });\n          this.textAdded = true;\n          this.canAddTextOrDoole.emit({ key: 'doodle', value: false });\n          this.canAddTextOrDoole.emit({ key: 'text', value: true });\n        } else {\n          activeObject.set({\n            hasControls: false,\n            selectable: false,\n            hasBorders: false,\n          });\n          this.canAddTextOrDoole.emit({ key: 'text', value: false });\n          this.canAddTextOrDoole.emit({ key: 'doodle', value: true });\n          this._canvas.selection = false;\n        }\n        this._canvas.renderAll();\n      });\n    }\n  }\n  public undo() {\n    this.isUndoing = true;\n    if (this.currentStateIndex > 0) {\n      this.currentStateIndex--;\n      const previousState = this.canvasStates[this.currentStateIndex];\n      this.canRedoOrUndo.emit({\n        canUndo: this.currentStateIndex > 0 ? true : false,\n        canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,\n      });\n\n      this._canvas.loadFromJSON(previousState.state, () => {\n        let activeObject = this._canvas.getActiveObject();\n        if (activeObject) {\n          if (activeObject.type !== 'path') {\n            activeObject.set({\n              padding: 42,\n              borderScaleFactor: 3,\n              borderColor: 'white',\n            });\n            this._canvas.isDrawingMode = false;\n            this._canvas.freeDrawingBrush = null;\n            this.textAdded = true;\n            this.canAddTextOrDoole.emit({ key: 'doodle', value: false });\n            this.canAddTextOrDoole.emit({ key: 'text', value: true });\n          } else {\n            activeObject.set({\n              hasControls: false,\n              hasBorders: false,\n            });\n            this._canvas.selection = false;\n            this.canAddTextOrDoole.emit({ key: 'text', value: false });\n            this.canAddTextOrDoole.emit({ key: 'doodle', value: true });\n          }\n          this._canvas.getActiveObject().controls =\n            previousState && previousState.customControl\n              ? previousState.customControl\n              : null;\n        }\n        this._canvas.getObjects().forEach((obj) => {\n          if (obj !== activeObject) {\n            obj.evented = false;\n          }\n        });\n        this._canvas.renderAll();\n      });\n    }\n  }\n  private getCanvasSize() {\n    const img = new Image();\n    img.src = this.src;\n    const box = this._component.nativeElement.getBoundingClientRect();\n\n    const width = this.width || box.width || 1;\n    const height = this.height || box.height || 1;\n    return { width, height };\n  }\n\n  /**\n   * recognize paper corners\n   */\n  private async build() {\n    if (!this.src || !this._canvas) {\n      return;\n    }\n    const bg = await this.loadBackgroundImage(this.src);\n\n    // Remove all the existing objects before add the new image to background\n    this._canvas.clear();\n\n    const imgSize = bg.getOriginalSize();\n    this.Image = {\n      height: imgSize.height * this._scaleFactor,\n      width: imgSize.width * this._scaleFactor,\n    };\n    const scaleX = this._canvas.width / imgSize.width;\n    const scaleY = this._canvas.height / imgSize.height;\n    this._scaleFactor = Math.min(scaleY, scaleX);\n    this._canvas.setDimensions(\n      {\n        width: imgSize.width,\n        height: imgSize.height,\n      },\n      {\n        backstoreOnly: true,\n      }\n    );\n    this._canvas.setBackgroundImage(bg, () => {\n      this._canvas.renderAll();\n    });\n    this.saveCanvasState();\n    this._canvas.renderAll();\n  }\n\n  private createControls(polygon: fabric.Polygon) {\n    // remove previous controls\n    if (this._controls.length) {\n      this._canvas.remove(...this._controls);\n      this._controls = [];\n    }\n    if (polygon) {\n      for (const [index, point] of polygon.points.entries()) {\n        const circle = this.createControl(index, polygon);\n        this._controls.push(circle);\n        this._canvas.add(circle);\n      }\n    }\n  }\n\n  private createControl(index: number, polygon: fabric.Polygon) {\n    const point = polygon.points[index];\n    const circle = new fabric.Circle({\n      left: point.x,\n      top: point.y,\n      originX: 'center',\n      originY: 'center',\n      fill: '#2188d9',\n      radius: 20,\n      hasRotatingPoint: false,\n      hasBorders: false,\n      hasControls: false,\n      objectCaching: false,\n    });\n    circle.on('moving', (evt) => {\n      if (evt.pointer) {\n        polygon.points[index] = new fabric.Point(evt.pointer.x, evt.pointer.y);\n        polygon.dirty = true;\n      }\n    });\n    circle.on('mouseup', (evt) => {\n      this.cornersChanged.emit();\n      this.screenPoints[index] = polygon.points[index];\n    });\n    return circle;\n  }\n\n  private loadBackgroundImage(src: string): Promise<fabric.Image> {\n    return new Promise((resolve, reject) => {\n      const img = new Image();\n      img.onload = () => {\n        let fabImage = new fabric.Image(img);\n        resolve(fabImage);\n      };\n      img.src = src;\n    });\n  }\n\n  public async completeScan(completed: boolean) {\n    if (!completed) {\n      return;\n    }\n    console.log(`complete scan & extract paper`);\n\n    if (!this._cornersPg) {\n      console.error(`Corner line is not available`);\n    }\n    if (this._cornersPg) {\n      this._canvas.remove(this._cornersPg);\n      this._canvas.remove(...this._controls);\n      this._canvas.renderAll();\n    }\n    let output: HTMLCanvasElement;\n    if (this.isScaned) {\n      output = await this._opencv.extractPaper({\n        src: this._canvas.toDataURL({ quality: 1 }),\n        corners: {\n          topLeftCorner: this.screenPoints[0],\n          topRightCorner: this.screenPoints[1],\n          bottomRightCorner: this.screenPoints[2],\n          bottomLeftCorner: this.screenPoints[3],\n        },\n        height: this._canvas.height,\n        width: this._canvas.width,\n      });\n      this._canvas.remove(...this._canvas.getObjects());\n      this.isScaned = false;\n    } else {\n      output = this._canvas.toCanvasElement();\n    }\n    this.currentStateIndex = null;\n    this.canvasStates = [];\n    this.canRedoOrUndo.emit({\n      canUndo: this.currentStateIndex > 0 ? true : false,\n      canRedo: this.currentStateIndex < this.canvasStates.length - 1 ? true : false,\n    });\n    this.extracted.emit(output);\n    this.cleanupCanvas();\n  }\n  private cleanupCanvas() {\n    this._canvas.getObjects().forEach((obj) => (obj.evented = false));\n    this._canvas.selection = false;\n    this._canvas.isDrawingMode = false;\n    this.canDoodle = false;\n    this.isScanStart = false;\n    this.canAddText = false;\n    this.textAdded = false;\n    this._canvas.renderAll();\n  }\n}\n","<div #componentWrapper\n     class=\"component\">\n    <canvas #drawCanas></canvas>\n  <div class=\"colors-container\" *ngIf=\"canDoodle || canAddText\">\n    <div class=\"colors\" *ngFor=\"let color of colors\" [ngStyle]=\"{'background': color.hexCode, 'border':color.selected ? '1.6px solid white' : 'none'}\" (click)=\"chngClrTextOrBrush(color.hexCode, canAddText ? 'text': 'doodle')\"></div>\n  </div>\n</div>\n"]}