@igo2/geo 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/print/shared/print.service.mjs

@@ -0,0 +1,1093 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, Subject, forkJoin } from 'rxjs';
+import { map as rxMap } from 'rxjs/operators';
+import { saveAs } from 'file-saver';
+import jsPDF from 'jspdf';
+import html2canvas from 'html2canvas';
+import { default as JSZip } from 'jszip';
+import { SubjectStatus } from '@igo2/utils';
+import { SecureImagePipe } from '@igo2/common';
+import { MessageService, ActivityService, LanguageService, ConfigService } from '@igo2/core';
+import { formatScale } from '../../map/shared/map.utils';
+import { getLayersLegends } from '../../layer/utils/outputLegend';
+import GeoPdfPlugin from './geopdf';
+import { PrintPaperFormat } from './print.type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@igo2/core";
+export class PrintService {
+    http;
+    messageService;
+    activityService;
+    languageService;
+    configService;
+    zipFile;
+    nbFileToProcess;
+    activityId;
+    imgSizeAdded;
+    TEXTPDFFONT = {
+        titleFont: 'Times',
+        titleFontStyle: 'bold',
+        subtitleFont: 'Times',
+        subtitleFontStyle: 'bold',
+        commentFont: 'courier',
+        commentFontStyle: 'normal',
+        commentFontSize: 12
+    };
+    constructor(http, messageService, activityService, languageService, configService) {
+        this.http = http;
+        this.messageService = messageService;
+        this.activityService = activityService;
+        this.languageService = languageService;
+        this.configService = configService;
+    }
+    print(map, options) {
+        const status$ = new Subject();
+        const paperFormat = options.paperFormat;
+        const resolution = +options.resolution; // Default is 96
+        const orientation = options.orientation;
+        const legendPostion = options.legendPosition;
+        this.activityId = this.activityService.register();
+        GeoPdfPlugin(jsPDF.API);
+        const doc = new jsPDF({
+            orientation,
+            format: paperFormat.toLowerCase(),
+            unit: 'mm' // default
+        });
+        const dimensions = [
+            doc.internal.pageSize.width,
+            doc.internal.pageSize.height
+        ];
+        const margins = [10, 10, 10, 10];
+        const width = dimensions[0] - margins[3] - margins[1];
+        const height = dimensions[1] - margins[0] - margins[2];
+        const size = [width, height];
+        let titleSizes;
+        let subtitleSizes;
+        // if paper format A1 or A0 add margin top
+        if ((options.title !== '' || options.subtitle !== '') &&
+            (paperFormat === PrintPaperFormat.A1 ||
+                paperFormat === PrintPaperFormat.A0)) {
+            margins[0] += 10;
+        }
+        // PDF title
+        const fontSizeInPt = Math.round(2 * (height + 145) * 0.05) / 2; //calculate the fontSize title from the page height.
+        if (options.title !== undefined && options.title !== '') {
+            titleSizes = this.getTextPdfObjectSizeAndMarg(options.title, margins, this.TEXTPDFFONT.titleFont, fontSizeInPt, this.TEXTPDFFONT.titleFontStyle, doc);
+            this.addTextInPdfDoc(doc, options.title, this.TEXTPDFFONT.titleFont, this.TEXTPDFFONT.titleFontStyle, titleSizes.fontSize, titleSizes.marginLeft + margins[3], margins[0]);
+            margins[0] = titleSizes.height + margins[0]; // cumulative margin top for next elem to place in pdf doc
+        }
+        // PDF subtitle
+        if (options.subtitle !== undefined && options.subtitle !== '') {
+            subtitleSizes = this.getTextPdfObjectSizeAndMarg(options.subtitle, margins, this.TEXTPDFFONT.subtitleFont, options.title !== '' ? titleSizes.fontSize * 0.7 : fontSizeInPt * 0.7, // 70% size of title
+            this.TEXTPDFFONT.subtitleFontStyle, doc);
+            this.addTextInPdfDoc(doc, options.subtitle, this.TEXTPDFFONT.subtitleFont, this.TEXTPDFFONT.subtitleFontStyle, subtitleSizes.fontSize, subtitleSizes.marginLeft + margins[3], margins[0]);
+            margins[0] += 5; // cumulative marg top for next elem to place in pdf doc. 5 is a fix it could be adjust
+        }
+        if (options.showProjection === true || options.showScale === true) {
+            this.addProjScale(doc, map, resolution, options.showProjection, options.showScale);
+        }
+        if (options.comment !== undefined && options.comment !== '') {
+            this.addComment(doc, options.comment);
+        }
+        this.addMap(doc, map, resolution, size, margins, legendPostion).subscribe(async (status) => {
+            if (status === SubjectStatus.Done) {
+                await this.handleMeasureLayer(doc, map, margins);
+                const width = this.imgSizeAdded[0];
+                const height = this.imgSizeAdded[1];
+                const res = 1;
+                this.addGeoRef(doc, map, width, height, res, margins);
+                if (options.legendPosition !== 'none') {
+                    if (['topleft', 'topright', 'bottomleft', 'bottomright'].indexOf(options.legendPosition) > -1) {
+                        await this.addLegendSamePage(doc, map, margins, resolution, options.legendPosition);
+                    }
+                    else if (options.legendPosition === 'newpage') {
+                        await this.addLegend(doc, map, margins, resolution);
+                    }
+                }
+                else {
+                    await this.saveDoc(doc);
+                }
+            }
+            if (status === SubjectStatus.Done || status === SubjectStatus.Error) {
+                this.activityService.unregister(this.activityId);
+                status$.next(SubjectStatus.Done);
+            }
+        });
+        return status$;
+    }
+    // ref GeoMoose https://github.com/geomoose/gm3/tree/main/src/gm3/components/print
+    addGeoRef(doc, map, width, height, resolution, margins) {
+        const unit = 'mm';
+        const docHeight = doc.internal.pageSize.getHeight();
+        // x,y = margin left-bottom corner for img in pdf doc
+        const x = margins[3];
+        const y = docHeight - margins[0] - height;
+        let pdf_extents = [x, y, x + width, y + height];
+        for (let i = 0; i < pdf_extents.length; i++) {
+            pdf_extents[i] = this.pdf_units2points(pdf_extents[i], unit);
+        }
+        const mapExtent = map.viewController.getExtent('EPSG:3857');
+        doc.setGeoArea(pdf_extents, mapExtent);
+    }
+    /**
+     * Add measure overlay on the map on the document when the measure layer is present
+     * @param  doc - Pdf document where measure tooltip will be added
+     * @param  map - Map of the app
+     * @param  margins - Page margins
+     */
+    async handleMeasureLayer(doc, map, margins) {
+        if (map.layers.find((layer) => layer.visible && layer.id.startsWith('igo-measures-'))) {
+            let canvasOverlayHTMLMeasures;
+            const mapOverlayMeasuresHTML = map.ol.getOverlayContainer();
+            await html2canvas(mapOverlayMeasuresHTML, {
+                scale: 1,
+                backgroundColor: null
+            }).then((e) => {
+                canvasOverlayHTMLMeasures = e;
+            });
+            this.addCanvas(doc, canvasOverlayHTMLMeasures, margins); // this adds measure overlays
+        }
+    }
+    /**
+     * Get html code for all layers legend
+     * @param  map IgoMap
+     * @param  width The width that the legend need to be
+     * @return Html code for the legend
+     */
+    getLayersLegendHtml(map, width, resolution) {
+        return new Observable((observer) => {
+            let html = '';
+            const legends = getLayersLegends(map.layers, {
+                resolution: map.viewController.getResolution(),
+                extent: map.viewController.getExtent(),
+                projection: map.viewController.getOlProjection().getCode(),
+                // scale: map.viewController.getScale(resolution),
+                size: map.ol.getSize()
+            });
+            if (legends.filter((l) => l.display === true).length === 0) {
+                observer.next(html);
+                observer.complete();
+                return;
+            }
+            // Define important style to be sure that all container is convert
+            // to image not just visible part
+            html += '<style media="screen" type="text/css">';
+            html +=
+                '.html2canvas-container { width: ' +
+                    width +
+                    'mm !important; height: 2000px !important; }';
+            html += 'table.tableLegend {table-layout: auto;}';
+            html +=
+                'div.styleLegend {padding-top: 5px; padding-right:5px;padding-left:5px;padding-bottom:5px;}';
+            html += '</style>';
+            // The font size will also be lowered afterwards (globally along the legend size)
+            // this allows having a good relative font size here and to keep ajusting the legend size
+            // while keeping good relative font size
+            html += '<font size="3" face="Times" >';
+            html += '<div class="styleLegend">';
+            html += '<table class="tableLegend" >';
+            // For each legend, define an html table cell
+            const images$ = legends
+                .filter((l) => l.display && l.isInResolutionsRange === true)
+                .map((legend) => this.getDataImage(legend.url).pipe(rxMap((dataImage) => {
+                let htmlImg = '<tr><td>' + legend.title.toUpperCase() + '</td></tr>';
+                htmlImg += '<tr><td><img src="' + dataImage + '"></td></tr>';
+                return htmlImg;
+            })));
+            forkJoin(images$).subscribe((dataImages) => {
+                html = dataImages.reduce((acc, current) => (acc += current), html);
+                html += '</table>';
+                html += '</div>';
+                observer.next(html);
+                observer.complete();
+            });
+        });
+    }
+    getDataImage(url) {
+        const secureIMG = new SecureImagePipe(this.http, this.configService);
+        return secureIMG.transform(url);
+    }
+    /**
+     * Get all the legend in a single image
+     * * @param  format - Image format. default value to "png"
+     * @return The image of the legend
+     */
+    async getLayersLegendImage(map, format = 'png', doZipFile, resolution) {
+        const status$ = new Subject();
+        // Get html code for the legend
+        const width = 200; // milimeters unit, originally define for document pdf
+        let html = await this.getLayersLegendHtml(map, width, resolution).toPromise();
+        format = format.toLowerCase();
+        // If no legend show No LEGEND in an image
+        if (html.length === 0) {
+            html = '<font size="12" face="Courier New" >';
+            html += '<div align="center"><b>NO LEGEND</b></div>';
+        }
+        // Create div to contain html code for legend
+        const div = window.document.createElement('div');
+        div.style.position = 'absolute';
+        div.style.top = '0';
+        div.style.zIndex = '-1';
+        // Add html code to convert in the new window
+        window.document.body.appendChild(div);
+        div.innerHTML = html;
+        await this.timeout(1);
+        const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {
+            console.log(e);
+        });
+        this.removeHtmlElement(div);
+        if (canvas) {
+            let status = SubjectStatus.Done;
+            try {
+                if (!doZipFile) {
+                    // Save the canvas as file
+                    this.saveCanvasImageAsFile(canvas, 'legendImage', format);
+                }
+                else {
+                    // Add the canvas to zip
+                    this.generateCanvaFileToZip(canvas, 'legendImage' + '.' + format);
+                }
+            }
+            catch (err) {
+                status = SubjectStatus.Error;
+            }
+            status$.next(status);
+        }
+        return status$;
+    }
+    removeHtmlElement(element) {
+        element.parentNode.removeChild(element);
+    }
+    getTextPdfObjectSizeAndMarg(text, margins, font, fontSizeInPt, fontStyle, doc) {
+        const pdfResolution = 96;
+        const docWidth = doc.internal.pageSize.getWidth();
+        const pageWidth = docWidth - margins[1] - margins[3];
+        // important to set it first, the textDimension change when font change!
+        doc.setFont(font, fontStyle);
+        doc.setFontSize(fontSizeInPt);
+        let textDimensions = doc.getTextDimensions(text);
+        let textMarginLeft;
+        if (textDimensions.w > pageWidth) {
+            // if the text is to long, reduce fontSize 70% and the overflow with be cut in print...
+            textMarginLeft = 0;
+            fontSizeInPt = fontSizeInPt * 0.7;
+            doc.setFontSize(fontSizeInPt);
+            textDimensions = doc.getTextDimensions(text);
+        }
+        else {
+            textMarginLeft = (pageWidth - textDimensions.w) / 2;
+        }
+        return {
+            fontSize: fontSizeInPt,
+            marginLeft: textMarginLeft,
+            height: textDimensions.h
+        };
+    }
+    /**
+     * Add comment to the document
+     * * @param  doc - pdf document
+     * * @param  comment - Comment to add in the document
+     */
+    addComment(doc, comment) {
+        const commentMarginLeft = 10; //margin left and bottom is fix
+        const commentMarginBottom = 10;
+        const marginTop = doc.internal.pageSize.height - commentMarginBottom;
+        this.addTextInPdfDoc(doc, comment, this.TEXTPDFFONT.commentFont, this.TEXTPDFFONT.commentFontStyle, this.TEXTPDFFONT.commentFontSize, commentMarginLeft, marginTop, true);
+    }
+    addTextInPdfDoc(doc, textToAdd, textFont, textFontStyle, textFontSize, textMarginLeft, textMarginTop, isComment = false) {
+        doc.setFont(textFont, textFontStyle);
+        doc.setFontSize(textFontSize);
+        if (isComment) {
+            textToAdd = doc.splitTextToSize(textToAdd, doc.internal.pageSize.getWidth() - textMarginLeft * 3);
+        }
+        doc.text(textToAdd, textMarginLeft, textMarginTop);
+    }
+    /**
+     * Add projection and/or scale to the document
+     * @param  doc - pdf document
+     * @param  map - Map of the app
+     * @param  dpi - DPI resolution of the document
+     * @param  projection - Bool to indicate if projection need to be added
+     * @param  scale - Bool to indicate if scale need to be added
+     */
+    addProjScale(doc, map, dpi, projection, scale) {
+        const translate = this.languageService.translate;
+        const projScaleSize = 12;
+        const projScaleMarginLeft = 10;
+        const marginBottom = 15;
+        const heightPixels = doc.internal.pageSize.height - marginBottom;
+        let textProjScale = '';
+        if (projection === true) {
+            const projText = translate.instant('igo.geo.printForm.projection');
+            textProjScale += projText + ': ' + map.projection;
+        }
+        if (scale === true) {
+            if (projection === true) {
+                textProjScale += '   ';
+            }
+            const scaleText = translate.instant('igo.geo.printForm.scale');
+            const mapScale = map.viewController.getScale(dpi);
+            textProjScale += scaleText + ': ~ 1 / ' + formatScale(mapScale);
+        }
+        doc.setFont('courier');
+        doc.setFontSize(projScaleSize);
+        doc.text(textProjScale, projScaleMarginLeft, heightPixels);
+    }
+    /**
+     * Add the legend to the document
+     * @param  doc - Pdf document where legend will be added
+     * @param  map - Map of the app
+     * @param  margins - Page margins
+     */
+    async addLegend(doc, map, margins, resolution) {
+        // Get html code for the legend
+        const width = doc.internal.pageSize.width;
+        const html = await this.getLayersLegendHtml(map, width, resolution).toPromise();
+        // If no legend, save the map directly
+        if (html === '') {
+            await this.saveDoc(doc);
+            return true;
+        }
+        // Create div to contain html code for legend
+        const div = window.document.createElement('div');
+        div.style.position = 'absolute';
+        div.style.top = '0';
+        div.style.zIndex = '-1';
+        // Add html code to convert in the new window
+        window.document.body.appendChild(div);
+        div.innerHTML = html;
+        await this.timeout(1);
+        const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {
+            console.log(e);
+        });
+        this.removeHtmlElement(div);
+        if (canvas) {
+            const pourcentageReduction = 0.85;
+            const imageSize = [
+                (pourcentageReduction * (25.4 * canvas.width)) / resolution,
+                (pourcentageReduction * (25.4 * canvas.height)) / resolution
+            ];
+            let imgData;
+            doc.addPage();
+            imgData = canvas.toDataURL('image/png');
+            doc.addImage(imgData, 'PNG', 10, 10, imageSize[0], imageSize[1]);
+        }
+        await this.saveDoc(doc);
+    }
+    /**
+     * Add the legend to the document
+     * @param  doc - Pdf document where legend will be added
+     * @param  map - Map of the app
+     * @param  margins - Page margins
+     */
+    async addLegendSamePage(doc, map, margins, resolution, legendPosition) {
+        // Get html code for the legend
+        const width = doc.internal.pageSize.width;
+        const html = await this.getLayersLegendHtml(map, width, resolution).toPromise();
+        // If no legend, save the map directly
+        if (html === '') {
+            await this.saveDoc(doc);
+            return true;
+        }
+        // Create div to contain html code for legend
+        const div = window.document.createElement('div');
+        div.style.position = 'absolute';
+        div.style.top = '0';
+        div.style.zIndex = '-1';
+        // Add html code to convert in the new window
+        window.document.body.appendChild(div);
+        div.innerHTML = html;
+        await this.timeout(1);
+        const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {
+            console.log(e);
+        });
+        this.removeHtmlElement(div);
+        let marginsLegend;
+        if (canvas) {
+            const pourcentageReduction = 0.85;
+            const imageSize = [
+                (pourcentageReduction * (25.4 * canvas.width)) / resolution,
+                (pourcentageReduction * (25.4 * canvas.height)) / resolution
+            ];
+            // Move the legend to the correct position on the page
+            if (legendPosition === 'bottomright') {
+                marginsLegend = [
+                    doc.internal.pageSize.height - margins[2] - imageSize[1],
+                    margins[1],
+                    margins[2],
+                    doc.internal.pageSize.width - margins[1] - imageSize[0]
+                ];
+            }
+            else if (legendPosition === 'topright') {
+                marginsLegend = [
+                    margins[0],
+                    margins[1],
+                    doc.internal.pageSize.height - margins[0] - imageSize[1],
+                    doc.internal.pageSize.width - margins[1] - imageSize[0]
+                ];
+            }
+            else if (legendPosition === 'bottomleft') {
+                // When the legend is in the bottom left, raise the legend slightly upward so that attributions are visible
+                marginsLegend = [
+                    doc.internal.pageSize.height - margins[2] - imageSize[1] - 15,
+                    doc.internal.pageSize.width - margins[3] - imageSize[0],
+                    margins[2] + 15,
+                    margins[3]
+                ];
+            }
+            else if (legendPosition === 'topleft') {
+                marginsLegend = [
+                    margins[0],
+                    doc.internal.pageSize.width - margins[3] - imageSize[0],
+                    doc.internal.pageSize.height - margins[0] - imageSize[1],
+                    margins[3]
+                ];
+            }
+            this.addCanvas(doc, canvas, marginsLegend); // this adds the legend
+            await this.saveDoc(doc);
+        }
+    }
+    defineNbFileToProcess(nbFileToProcess) {
+        this.nbFileToProcess = nbFileToProcess;
+    }
+    timeout(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    addCanvas(doc, canvas, margins) {
+        let image;
+        if (canvas) {
+            image = canvas.toDataURL('image/png');
+        }
+        if (image !== undefined) {
+            if (image.length < 20) {
+                console.log('Warning: An image cannot be print in pdf file');
+                return;
+            }
+            const imageSize = this.getImageSizeToFitPdf(doc, canvas, margins);
+            doc.addImage(image, 'PNG', margins[3], margins[0], imageSize[0], imageSize[1]);
+            doc.rect(margins[3], margins[0], imageSize[0], imageSize[1]);
+            this.imgSizeAdded = imageSize; // keep img size for georef later
+        }
+    }
+    // TODO fix printing with image resolution
+    addMap(doc, map, resolution, docSize, margins, legendPostion) {
+        const mapSize = map.ol.getSize();
+        const viewResolution = map.ol.getView().getResolution();
+        const dimensionPixels = this.setMapResolution(map, docSize, resolution, viewResolution);
+        const status$ = new Subject();
+        let timeout;
+        map.ol.once('rendercomplete', async (event) => {
+            const mapCanvas = event.target
+                .getViewport()
+                .getElementsByTagName('canvas');
+            const mapResultCanvas = await this.drawMap(dimensionPixels, mapCanvas);
+            this.resetOriginalMapSize(map, mapSize, viewResolution);
+            await this.drawMapControls(map, mapResultCanvas, legendPostion);
+            const mapStatus$$ = map.status$.subscribe((mapStatus) => {
+                clearTimeout(timeout);
+                if (mapStatus !== SubjectStatus.Done) {
+                    return;
+                }
+                mapStatus$$.unsubscribe();
+                let status = SubjectStatus.Done;
+                try {
+                    if (mapResultCanvas.width !== 0) {
+                        this.addCanvas(doc, mapResultCanvas, margins);
+                    }
+                }
+                catch (err) {
+                    status = SubjectStatus.Error;
+                    this.messageService.error('igo.geo.printForm.corsErrorMessageBody', 'igo.geo.printForm.corsErrorMessageHeader');
+                }
+                status$.next(status);
+            });
+            // If no loading as started after 200ms, then probably no loading
+            // is required.
+            timeout = window.setTimeout(() => {
+                mapStatus$$.unsubscribe();
+                let status = SubjectStatus.Done;
+                try {
+                    if (mapResultCanvas.width !== 0) {
+                        this.addCanvas(doc, mapResultCanvas, margins);
+                    }
+                }
+                catch (err) {
+                    status = SubjectStatus.Error;
+                    this.messageService.error('igo.geo.printForm.corsErrorMessageBody', 'igo.geo.printForm.corsErrorMessageHeader');
+                }
+                this.resetOriginalMapSize(map, mapSize, viewResolution);
+                status$.next(status);
+            }, 200);
+        });
+        return status$;
+    }
+    setMapResolution(map, initialSize, resolution, viewResolution) {
+        const mapSize = map.ol.getSize();
+        const widthPixels = Math.round((initialSize[0] * resolution) / 25.4);
+        const heightPixels = Math.round((initialSize[1] * resolution) / 25.4);
+        // Set print size
+        const printSize = [widthPixels, heightPixels];
+        map.ol.setSize(printSize);
+        const scaling = Math.min(widthPixels / mapSize[0], heightPixels / mapSize[1]);
+        map.ol.getView().setResolution(viewResolution / scaling);
+        return [widthPixels, heightPixels];
+    }
+    resetOriginalMapSize(map, initialSize, viewResolution) {
+        map.ol.setSize(initialSize);
+        map.ol.getView().setResolution(viewResolution);
+        map.ol.updateSize();
+        map.ol.renderSync();
+    }
+    async drawMap(size, mapCanvas) {
+        const mapResultCanvas = document.createElement('canvas');
+        mapResultCanvas.width = size[0];
+        mapResultCanvas.height = size[1];
+        for (let index = 0; index < mapCanvas.length; index++) {
+            const canvas = mapCanvas[index];
+            if (canvas.width > 0) {
+                this.handleCanvas(canvas, mapResultCanvas);
+            }
+        }
+        return mapResultCanvas;
+    }
+    handleCanvas(canvas, mapResultCanvas) {
+        const mapContextResult = mapResultCanvas.getContext('2d');
+        const opacity = canvas.parentElement.style.opacity || canvas.style.opacity;
+        mapContextResult.globalAlpha = opacity === '' ? 1 : Number(opacity);
+        const transform = canvas.style.transform;
+        let matrix;
+        if (transform) {
+            // Get the transform parameters from the style's transform matrix
+            matrix = transform
+                .match(/^matrix\(([^\(]*)\)$/)[1]
+                .split(',')
+                .map(Number);
+        }
+        else {
+            matrix = [
+                parseFloat(canvas.style.width) / canvas.width,
+                0,
+                0,
+                parseFloat(canvas.style.height) / canvas.height,
+                0,
+                0
+            ];
+        }
+        CanvasRenderingContext2D.prototype.setTransform.apply(mapContextResult, matrix);
+        const backgroundColor = canvas.parentElement.style.backgroundColor;
+        if (backgroundColor) {
+            mapContextResult.fillStyle = backgroundColor;
+            mapContextResult.fillRect(0, 0, canvas.width, canvas.height);
+        }
+        mapContextResult.drawImage(canvas, 0, 0);
+        mapContextResult.globalAlpha = 1;
+        // reset canvas transform to initial
+        mapContextResult.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    async drawMapControls(map, canvas, position) {
+        const context = canvas.getContext('2d');
+        // Get the scale and attribution
+        // we use cloneNode to modify the nodes to print without modifying it on the page, using deep:true to get children
+        const mapOverlayHTML = map.ol
+            .getOverlayContainerStopEvent()
+            .cloneNode(true);
+        // add North Direction to mapOverly
+        await this.addNorthDirection(mapOverlayHTML, position);
+        // add map Attribution designe to print
+        await this.addAttribution(mapOverlayHTML);
+        // set 'OverlayContainer' size to print size
+        mapOverlayHTML.style.width = canvas.width + 'px';
+        mapOverlayHTML.style.height = canvas.height + 'px';
+        // we add zindex -1 to not show modification to the user
+        mapOverlayHTML.style.zIndex = '-1';
+        // and make sure html2canvas to render the image correctly
+        document
+            .getElementsByClassName('ol-viewport')[0]
+            .appendChild(mapOverlayHTML);
+        // Change the styles of hyperlink in the printed version
+        // Transform the Overlay into a canvas
+        // scale is necessary to make it in google chrome
+        // background as null because otherwise it is white and cover the map
+        // allowtaint is to allow rendering images in the attributions
+        // useCORS: true pour permettre de renderer les images (ne marche pas en local)
+        const canvasOverlayHTML = await html2canvas(mapOverlayHTML, {
+            scale: 1,
+            backgroundColor: null,
+            allowTaint: true,
+            useCORS: true
+        });
+        context.drawImage(canvasOverlayHTML, 0, 0);
+        // remove 'mapOverlayHTML' after generating canvas
+        mapOverlayHTML.remove();
+    }
+    async addNorthDirection(mapOverlayHTML, position) {
+        const northDirection = document
+            .getElementsByTagName('igo-rotation-button')[0]
+            .cloneNode(true);
+        const HTMLButton = northDirection.getElementsByTagName('button')[0];
+        if (!HTMLButton) {
+            return null;
+        }
+        // in case legend position is topright
+        // we change rotate btn to topleft
+        if (position === 'topright') {
+            northDirection.style.width = 'inherit';
+            northDirection.style.left = '10px';
+        }
+        HTMLButton.parentElement.style.background = 'transparent';
+        HTMLButton.style.color = '#000';
+        mapOverlayHTML.appendChild(northDirection);
+    }
+    async addAttribution(mapOverlayHTML) {
+        const HTMLattribution = mapOverlayHTML.getElementsByClassName('ol-attribution')[0];
+        const HTMLButton = HTMLattribution.getElementsByTagName('button')[0];
+        if (!HTMLButton) {
+            return null;
+        }
+        HTMLButton.setAttribute('data-html2canvas-ignore', 'true');
+        const olCollapsed = HTMLattribution.classList.contains('ol-collapsed');
+        if (olCollapsed) {
+            HTMLattribution.classList.remove('ol-collapsed');
+        }
+    }
+    /**
+     * Download an image of the map with addition of informations
+     * @param  map - Map of the app
+     * @param  format - Image format. default value to "png"
+     * @param  projection - Indicate if projection need to be add. Default to false
+     * @param  scale - Indicate if scale need to be add. Default to false
+     * @param  legend - Indicate if the legend of layers need to be download. Default to false
+     * @param  title - Title to add for the map - Default to blank
+     * @param  subtitle - Subtitle to add for the map - Default to blank
+     * @param  comment - Comment to add for the map - Default to blank
+     * @param  doZipFile - Indicate if we do a zip with the file
+     * @return Image file of the map with extension format given as parameter
+     */
+    downloadMapImage(map, printResolution, format = 'png', projection = false, scale = false, title = '', subtitle = '', comment = '', doZipFile = true, legendPosition) {
+        const status$ = new Subject();
+        this.activityId = this.activityService.register();
+        const translate = this.languageService.translate;
+        format = format.toLowerCase();
+        const resolution = +printResolution;
+        const initialMapSize = map.ol.getSize();
+        const viewResolution = map.ol.getView().getResolution();
+        map.ol.once('rendercomplete', async (event) => {
+            const size = map.ol.getSize();
+            const mapCanvas = event.target
+                .getViewport()
+                .getElementsByTagName('canvas');
+            const mapResultCanvas = await this.drawMap(size, mapCanvas);
+            this.resetOriginalMapSize(map, initialMapSize, viewResolution);
+            await this.drawMapControls(map, mapResultCanvas, legendPosition);
+            // Check the legendPosition
+            if (legendPosition !== 'none') {
+                if (['topleft', 'topright', 'bottomleft', 'bottomright'].indexOf(legendPosition) > -1) {
+                    await this.addLegendToImage(mapResultCanvas, map, resolution, legendPosition, format);
+                }
+                else if (legendPosition === 'newpage') {
+                    await this.getLayersLegendImage(map, format, doZipFile, resolution);
+                }
+            }
+            // add other information to final canvas before exporting
+            const newCanvas = document.createElement('canvas');
+            const newContext = newCanvas.getContext('2d');
+            // Postion in height to set the canvas in new canvas
+            let positionHCanvas = 0;
+            // Get height/width of map canvas
+            const width = mapResultCanvas.width;
+            let height = mapResultCanvas.height;
+            // Set Font to calculate comment width
+            newContext.font = '20px Calibri';
+            const commentWidth = newContext.measureText(comment).width;
+            // Add height for title if defined
+            height = title !== '' ? height + 30 : height;
+            // Add height for title if defined
+            height = subtitle !== '' ? height + 30 : height;
+            // Add height for projection or scale (same line) if defined
+            height = projection !== false || scale !== false ? height + 30 : height;
+            const positionHProjScale = height - 10;
+            // Define number of line depending of the comment length
+            const commentNbLine = Math.ceil(commentWidth / width);
+            // Add height for multiline comment if defined
+            height = comment !== '' ? height + commentNbLine * 30 : height;
+            let positionHComment = height - commentNbLine * 20 + 5;
+            // Set the new canvas with the new calculated size
+            newCanvas.width = width;
+            newCanvas.height = height;
+            if (['bmp', 'gif', 'jpeg', 'png', 'tiff'].indexOf(format) > -1) {
+                // Patch Jpeg default black background to white
+                if (format === 'jpeg' ||
+                    title !== '' ||
+                    subtitle !== '' ||
+                    comment !== '' ||
+                    projection !== false ||
+                    scale !== false) {
+                    newContext.fillStyle = '#ffffff';
+                    newContext.fillRect(0, 0, width, height);
+                    newContext.fillStyle = '#000000';
+                }
+            }
+            // If a title need to be added to canvas
+            if (title !== '') {
+                // Set font for title
+                // Adjust according to title length
+                newContext.font = '26px Calibri';
+                positionHCanvas = 30;
+                newContext.textAlign = 'center';
+                newContext.fillText(title, width / 2, 20, width * 0.9);
+            }
+            if (subtitle !== '') {
+                // Set font for subtitle
+                // Adjust according to title length
+                newContext.font = '26px Calibri';
+                positionHCanvas = 60;
+                newContext.textAlign = 'center';
+                newContext.fillText(subtitle, width / 2, 50, width * 0.9);
+            }
+            // Set font for next section
+            newContext.font = '20px Calibri';
+            // If projection or/end scale need to be added to canvas
+            if (projection !== false || scale !== false) {
+                let projectionScaleText = '';
+                if (projection !== false) {
+                    const projText = translate.instant('igo.geo.printForm.projection');
+                    projectionScaleText = projText + ': ' + map.projection + '         ';
+                }
+                if (scale !== false) {
+                    const scaleText = translate.instant('igo.geo.printForm.scale');
+                    const mapScale = map.viewController.getScale(resolution);
+                    projectionScaleText += scaleText + ': ~ 1 / ' + formatScale(mapScale);
+                }
+                newContext.textAlign = 'center';
+                newContext.fillText(projectionScaleText, width / 2, positionHProjScale, width * 0.9);
+            }
+            // If a comment need to be added to canvas
+            if (comment !== '') {
+                newContext.textAlign = 'center';
+                // If only one line, no need to multiline the comment
+                if (commentNbLine === 1) {
+                    newContext.fillText(comment, width / 2, positionHComment);
+                }
+                else {
+                    // Separate the setenses to be approx. the same length
+                    const nbCommentChar = comment.length;
+                    const CommentLengthToCut = Math.floor(nbCommentChar / commentNbLine);
+                    let commentCurrentLine = '';
+                    let positionFirstCutChar = 0;
+                    let positionLastBlank;
+                    // Loop for the number of line calculated
+                    for (let i = 0; i < commentNbLine; i++) {
+                        // For all line except last
+                        if (commentNbLine - 1 > i) {
+                            // Get comment current line to find the right place tu cut comment
+                            commentCurrentLine = comment.substr(positionFirstCutChar, CommentLengthToCut);
+                            // Cut the setence at blank
+                            positionLastBlank = commentCurrentLine.lastIndexOf(' ');
+                            newContext.fillText(commentCurrentLine.substr(0, positionLastBlank), width / 2, positionHComment);
+                            positionFirstCutChar += positionLastBlank;
+                            // Go to next line for insertion
+                            positionHComment += 20;
+                        }
+                        else {
+                            // Don't cut last part
+                            newContext.fillText(comment.substr(positionFirstCutChar), width / 2, positionHComment);
+                        }
+                    }
+                }
+            }
+            newContext.drawImage(mapResultCanvas, 0, positionHCanvas);
+            let status = SubjectStatus.Done;
+            let fileNameWithExt = 'map.' + format;
+            if (format.toLowerCase() === 'tiff') {
+                fileNameWithExt =
+                    'map' + map.projection.replace(':', '_') + '.' + format;
+            }
+            try {
+                // Save the canvas as file
+                if (!doZipFile) {
+                    this.saveCanvasImageAsFile(newCanvas, fileNameWithExt, format);
+                }
+                else if (format.toLowerCase() === 'tiff') {
+                    // Add the canvas to zip
+                    this.generateCanvaFileToZip(newCanvas, fileNameWithExt);
+                }
+                else {
+                    // Add the canvas to zip
+                    this.generateCanvaFileToZip(newCanvas, fileNameWithExt);
+                }
+            }
+            catch (err) {
+                status = SubjectStatus.Error;
+            }
+            status$.next(status);
+            if (format.toLowerCase() === 'tiff') {
+                const tfwFileNameWithExt = fileNameWithExt.substring(0, fileNameWithExt.toLowerCase().indexOf('.tiff')) + '.tfw';
+                const tiwContent = this.getWorldFileInformation(map);
+                const blob = new Blob([tiwContent], {
+                    type: 'text/plain;charset=utf-8'
+                });
+                if (!doZipFile) {
+                    // saveAs automaticly replace ':' for '_'
+                    saveAs(blob, tfwFileNameWithExt);
+                    this.saveFileProcessing();
+                }
+                else {
+                    // Add the canvas to zip
+                    this.addFileToZip(tfwFileNameWithExt, blob);
+                }
+            }
+        });
+        this.setMapImageResolution(map, initialMapSize, resolution, viewResolution);
+        return status$;
+    }
+    setMapImageResolution(map, initialMapSize, resolution, viewResolution) {
+        const scaleFactor = resolution / 96;
+        const newMapSize = [
+            Math.round(initialMapSize[0] * scaleFactor),
+            Math.round(initialMapSize[1] * scaleFactor) // height
+        ];
+        map.ol.setSize(newMapSize);
+        const scaling = Math.min(newMapSize[0] / initialMapSize[0], newMapSize[1] / initialMapSize[1]);
+        const view = map.ol.getView();
+        view.setResolution(viewResolution / scaling);
+        map.ol.renderSync();
+    }
+    /**
+     * Create and Add Legend to the map canvas
+     * @param  canvas Canvas of the map
+     * @param  map Map of the app
+     * @param  resolution Resolution of map
+     * @param  legendPosition Legend position
+     * @param  format Image format
+     */
+    async addLegendToImage(canvas, map, resolution, legendPosition, format) {
+        const fileNameWithExt = 'map.' + format;
+        const context = canvas.getContext('2d');
+        // Get html code for the legend
+        const html = await this.getLayersLegendHtml(map, canvas.width, resolution).toPromise();
+        // If no legend, save the map directly
+        if (html === '') {
+            await this.saveCanvasImageAsFile(canvas, fileNameWithExt, format);
+            return true;
+        }
+        // Create div to contain html code for legend
+        const div = window.document.createElement('div');
+        div.style.position = 'absolute';
+        div.style.top = '0';
+        div.style.zIndex = '-1';
+        // Add html code to convert in the new window
+        window.document.body.appendChild(div);
+        div.innerHTML = html;
+        await this.timeout(1);
+        const canvasLegend = await html2canvas(div, { useCORS: true }).catch((e) => {
+            console.log(e);
+        });
+        if (canvasLegend) {
+            const canvasHeight = canvas.height;
+            const canvasWidth = canvas.width;
+            const legendHeight = canvasLegend.height;
+            const legendWidth = canvasLegend.width;
+            // Move the legend to the correct position on the page
+            const offset = canvasHeight * 0.01;
+            let legendX;
+            let legendY;
+            if (legendPosition === 'bottomright') {
+                legendX = canvasWidth - legendWidth - offset;
+                legendY = canvasHeight - legendHeight - offset;
+            }
+            else if (legendPosition === 'topright') {
+                legendX = canvasWidth - legendWidth - offset;
+                legendY = offset;
+            }
+            else if (legendPosition === 'bottomleft') {
+                legendX = offset;
+                legendY = canvasHeight - legendHeight - offset - 15;
+            }
+            else if (legendPosition === 'topleft') {
+                legendX = offset;
+                legendY = offset;
+            }
+            context.drawImage(canvasLegend, legendX, legendY, legendWidth, legendHeight);
+            context.strokeRect(legendX, legendY, legendWidth, legendHeight);
+            this.removeHtmlElement(div);
+            return true;
+        }
+    }
+    renderMap(map, size, extent) {
+        map.ol.updateSize();
+        map.ol.renderSync();
+    }
+    /**
+     * Save document
+     * @param  doc - Document to save
+     */
+    async saveDoc(doc) {
+        await doc.save('map_georef.pdf', { returnPromise: true });
+    }
+    /**
+     * Calculate the best Image size to fit in pdf
+     * @param doc - Pdf Document
+     * @param canvas - Canvas of image
+     * @param margins - Page margins
+     */
+    getImageSizeToFitPdf(doc, canvas, margins) {
+        // Define variable to calculate best size to fit in one page
+        const pageHeight = doc.internal.pageSize.getHeight() - (margins[0] + margins[2] + 10);
+        const pageWidth = doc.internal.pageSize.getWidth() - (margins[1] + margins[3]);
+        const canHeight = this.pdf_units2points(canvas.height, 'mm');
+        const canWidth = this.pdf_units2points(canvas.width, 'mm');
+        const heightRatio = canHeight / pageHeight;
+        const widthRatio = canWidth / pageWidth;
+        const maxRatio = heightRatio > widthRatio ? heightRatio : widthRatio;
+        const imgHeigh = maxRatio > 1 ? canHeight / maxRatio : canHeight;
+        const imgWidth = maxRatio > 1 ? canWidth / maxRatio : canWidth;
+        return [imgWidth, imgHeigh];
+    }
+    /**
+     * Get a world file information for tiff
+     * @param  map - Map of the app
+     */
+    getWorldFileInformation(map) {
+        const currentResolution = map.viewController.getResolution();
+        const currentExtent = map.viewController.getExtent(); // Return [minx, miny, maxx, maxy]
+        return [
+            currentResolution,
+            0,
+            0,
+            -currentResolution,
+            currentExtent[0] + currentResolution / 0.5,
+            currentExtent[3] - currentResolution / 0.5
+        ].join('\n');
+    }
+    /**
+     * Save canvas image as file
+     * @param canvas - Canvas to save
+     * @param name - Name of the file
+     * @param format - file format
+     */
+    saveCanvasImageAsFile(canvas, nameWithExt, format) {
+        const blobFormat = 'image/' + format;
+        const that = this;
+        try {
+            canvas.toDataURL(); // Just to make the catch trigger wihtout toBlob Error throw not catched
+            canvas.toBlob((blob) => {
+                // download image
+                saveAs(blob, nameWithExt);
+                that.saveFileProcessing();
+            }, blobFormat);
+        }
+        catch (err) {
+            this.messageService.error('igo.geo.printForm.corsErrorMessageBody', 'igo.geo.printForm.corsErrorMessageHeader');
+        }
+    }
+    /**
+     * Add file to a zip
+     * @param canvas - File to add to the zip
+     * @param  name -Name of the fileoverview
+     */
+    generateCanvaFileToZip(canvas, name) {
+        const blobFormat = 'image/' + 'jpeg';
+        const that = this;
+        if (!this.hasOwnProperty('zipFile') ||
+            typeof this.zipFile === 'undefined') {
+            this.zipFile = new JSZip();
+        }
+        try {
+            canvas.toDataURL(); // Just to make the catch trigger wihtout toBlob Error throw not catched
+            if (navigator.msSaveBlob) {
+                this.addFileToZip(name, canvas.msToBlob());
+            }
+            else {
+                canvas.toBlob((blob) => {
+                    that.addFileToZip(name, blob);
+                }, blobFormat);
+            }
+        }
+        catch (err) {
+            this.messageService.error('igo.geo.printForm.corsErrorMessageBody', 'igo.geo.printForm.corsErrorMessageHeader');
+        }
+    }
+    /**
+     * Add file to zip, if all file are zipped, download
+     * @param name - Name of the files
+     * @param blob - Contain of file
+     */
+    addFileToZip(name, blob) {
+        // add file to zip
+        this.zipFile.file(name, blob);
+        this.nbFileToProcess--;
+        // If all files are proccessed
+        if (this.nbFileToProcess === 0) {
+            // Download zip file
+            this.getZipFile();
+            // Stop loading
+            this.activityService.unregister(this.activityId);
+        }
+    }
+    saveFileProcessing() {
+        this.nbFileToProcess--;
+        // If all files are proccessed
+        if (this.nbFileToProcess === 0) {
+            // Stop loading
+            this.activityService.unregister(this.activityId);
+        }
+    }
+    /**
+     * Get the zipped file
+     * @return Retun a zip file
+     */
+    getZipFile() {
+        const that = this;
+        this.zipFile.generateAsync({ type: 'blob' }).then((blob) => {
+            // 1) generate the zip file
+            saveAs(blob, 'map.zip');
+            delete that.zipFile;
+        });
+    }
+    pdf_units2points(n, unit) {
+        let k = 1;
+        // this code is borrowed from jsPDF
+        //  as it does not expose a public API
+        //  for converting units to points.
+        switch (unit) {
+            case 'pt':
+                k = 1;
+                break;
+            case 'mm':
+                k = 72 / 25.4;
+                break;
+            case 'cm':
+                k = 72 / 2.54;
+                break;
+            case 'in':
+                k = 72;
+                break;
+            case 'px':
+                k = 96 / 72;
+                break;
+            case 'pc':
+                k = 12;
+                break;
+            case 'em':
+                k = 12;
+                break;
+            case 'ex':
+                k = 6;
+                break;
+            default:
+                throw new Error('Invalid unit: ' + unit);
+        }
+        return n * k;
+    }
+    static ɵfac = function PrintService_Factory(t) { return new (t || PrintService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.MessageService), i0.ɵɵinject(i2.ActivityService), i0.ɵɵinject(i2.LanguageService), i0.ɵɵinject(i2.ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PrintService, factory: PrintService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PrintService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.MessageService }, { type: i2.ActivityService }, { type: i2.LanguageService }, { type: i2.ConfigService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"print.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/print/shared/print.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\n\r\nimport { Observable, Subject, forkJoin } from 'rxjs';\r\nimport { map as rxMap } from 'rxjs/operators';\r\n\r\nimport { saveAs } from 'file-saver';\r\nimport jsPDF from 'jspdf';\r\nimport html2canvas from 'html2canvas';\r\nimport { default as JSZip } from 'jszip';\r\n\r\nimport { SubjectStatus } from '@igo2/utils';\r\nimport { SecureImagePipe } from '@igo2/common';\r\nimport {\r\n  MessageService,\r\n  ActivityService,\r\n  LanguageService,\r\n  ConfigService\r\n} from '@igo2/core';\r\n\r\nimport { IgoMap } from '../../map/shared/map';\r\nimport { formatScale } from '../../map/shared/map.utils';\r\nimport { LegendMapViewOptions } from '../../layer/shared/layers/legend.interface';\r\nimport { getLayersLegends } from '../../layer/utils/outputLegend';\r\n\r\nimport { PrintOptions, TextPdfSizeAndMargin } from './print.interface';\r\nimport GeoPdfPlugin from './geopdf';\r\nimport {\r\n  PrintLegendPosition,\r\n  PrintPaperFormat,\r\n  PrintResolution\r\n} from './print.type';\r\n\r\ndeclare global {\r\n  interface Navigator {\r\n    msSaveBlob?: (blob: any, defaultName?: string) => boolean;\r\n  }\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PrintService {\r\n  zipFile: JSZip;\r\n  nbFileToProcess: number;\r\n  activityId: string;\r\n  imgSizeAdded: Array<number>;\r\n\r\n  TEXTPDFFONT = {\r\n    titleFont: 'Times',\r\n    titleFontStyle: 'bold',\r\n    subtitleFont: 'Times',\r\n    subtitleFontStyle: 'bold',\r\n    commentFont: 'courier',\r\n    commentFontStyle: 'normal',\r\n    commentFontSize: 12\r\n  };\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private messageService: MessageService,\r\n    private activityService: ActivityService,\r\n    private languageService: LanguageService,\r\n    private configService: ConfigService\r\n  ) {}\r\n\r\n  print(map: IgoMap, options: PrintOptions): Subject<any> {\r\n    const status$ = new Subject();\r\n    const paperFormat: string = options.paperFormat;\r\n    const resolution = +options.resolution; // Default is 96\r\n    const orientation = options.orientation;\r\n    const legendPostion = options.legendPosition;\r\n    this.activityId = this.activityService.register();\r\n\r\n    GeoPdfPlugin(jsPDF.API);\r\n\r\n    const doc = new jsPDF({\r\n      orientation,\r\n      format: paperFormat.toLowerCase(),\r\n      unit: 'mm' // default\r\n    });\r\n\r\n    const dimensions = [\r\n      doc.internal.pageSize.width,\r\n      doc.internal.pageSize.height\r\n    ];\r\n\r\n    const margins = [10, 10, 10, 10];\r\n    const width = dimensions[0] - margins[3] - margins[1];\r\n    const height = dimensions[1] - margins[0] - margins[2];\r\n    const size: [number, number] = [width, height];\r\n    let titleSizes: TextPdfSizeAndMargin;\r\n    let subtitleSizes: TextPdfSizeAndMargin;\r\n\r\n    // if paper format A1 or A0 add margin top\r\n    if (\r\n      (options.title !== '' || options.subtitle !== '') &&\r\n      (paperFormat === PrintPaperFormat.A1 ||\r\n        paperFormat === PrintPaperFormat.A0)\r\n    ) {\r\n      margins[0] += 10;\r\n    }\r\n    // PDF title\r\n    const fontSizeInPt = Math.round(2 * (height + 145) * 0.05) / 2; //calculate the fontSize title from the page height.\r\n    if (options.title !== undefined && options.title !== '') {\r\n      titleSizes = this.getTextPdfObjectSizeAndMarg(\r\n        options.title,\r\n        margins,\r\n        this.TEXTPDFFONT.titleFont,\r\n        fontSizeInPt,\r\n        this.TEXTPDFFONT.titleFontStyle,\r\n        doc\r\n      );\r\n\r\n      this.addTextInPdfDoc(\r\n        doc,\r\n        options.title,\r\n        this.TEXTPDFFONT.titleFont,\r\n        this.TEXTPDFFONT.titleFontStyle,\r\n        titleSizes.fontSize,\r\n        titleSizes.marginLeft + margins[3],\r\n        margins[0]\r\n      );\r\n\r\n      margins[0] = titleSizes.height + margins[0]; // cumulative margin top for next elem to place in pdf doc\r\n    }\r\n\r\n    // PDF subtitle\r\n    if (options.subtitle !== undefined && options.subtitle !== '') {\r\n      subtitleSizes = this.getTextPdfObjectSizeAndMarg(\r\n        options.subtitle,\r\n        margins,\r\n        this.TEXTPDFFONT.subtitleFont,\r\n        options.title !== '' ? titleSizes.fontSize * 0.7 : fontSizeInPt * 0.7, // 70% size of title\r\n        this.TEXTPDFFONT.subtitleFontStyle,\r\n        doc\r\n      );\r\n\r\n      this.addTextInPdfDoc(\r\n        doc,\r\n        options.subtitle,\r\n        this.TEXTPDFFONT.subtitleFont,\r\n        this.TEXTPDFFONT.subtitleFontStyle,\r\n        subtitleSizes.fontSize,\r\n        subtitleSizes.marginLeft + margins[3],\r\n        margins[0]\r\n      );\r\n\r\n      margins[0] += 5; // cumulative marg top for next elem to place in pdf doc. 5 is a fix it could be adjust\r\n    }\r\n\r\n    if (options.showProjection === true || options.showScale === true) {\r\n      this.addProjScale(\r\n        doc,\r\n        map,\r\n        resolution,\r\n        options.showProjection,\r\n        options.showScale\r\n      );\r\n    }\r\n    if (options.comment !== undefined && options.comment !== '') {\r\n      this.addComment(doc, options.comment);\r\n    }\r\n\r\n    this.addMap(doc, map, resolution, size, margins, legendPostion).subscribe(\r\n      async (status: SubjectStatus) => {\r\n        if (status === SubjectStatus.Done) {\r\n          await this.handleMeasureLayer(doc, map, margins);\r\n\r\n          const width = this.imgSizeAdded[0];\r\n          const height = this.imgSizeAdded[1];\r\n          const res = 1;\r\n          this.addGeoRef(doc, map, width, height, res, margins);\r\n\r\n          if (options.legendPosition !== 'none') {\r\n            if (\r\n              ['topleft', 'topright', 'bottomleft', 'bottomright'].indexOf(\r\n                options.legendPosition\r\n              ) > -1\r\n            ) {\r\n              await this.addLegendSamePage(\r\n                doc,\r\n                map,\r\n                margins,\r\n                resolution,\r\n                options.legendPosition\r\n              );\r\n            } else if (options.legendPosition === 'newpage') {\r\n              await this.addLegend(doc, map, margins, resolution);\r\n            }\r\n          } else {\r\n            await this.saveDoc(doc);\r\n          }\r\n        }\r\n\r\n        if (status === SubjectStatus.Done || status === SubjectStatus.Error) {\r\n          this.activityService.unregister(this.activityId);\r\n          status$.next(SubjectStatus.Done);\r\n        }\r\n      }\r\n    );\r\n\r\n    return status$;\r\n  }\r\n  // ref GeoMoose https://github.com/geomoose/gm3/tree/main/src/gm3/components/print\r\n  addGeoRef(doc, map, width, height, resolution, margins) {\r\n    const unit = 'mm';\r\n    const docHeight = doc.internal.pageSize.getHeight();\r\n\r\n    // x,y = margin left-bottom corner for img in pdf doc\r\n    const x = margins[3];\r\n    const y = docHeight - margins[0] - height;\r\n\r\n    let pdf_extents = [x, y, x + width, y + height];\r\n    for (let i = 0; i < pdf_extents.length; i++) {\r\n      pdf_extents[i] = this.pdf_units2points(pdf_extents[i], unit);\r\n    }\r\n\r\n    const mapExtent = map.viewController.getExtent('EPSG:3857');\r\n    doc.setGeoArea(pdf_extents, mapExtent);\r\n  }\r\n\r\n  /**\r\n   * Add measure overlay on the map on the document when the measure layer is present\r\n   * @param  doc - Pdf document where measure tooltip will be added\r\n   * @param  map - Map of the app\r\n   * @param  margins - Page margins\r\n   */\r\n  private async handleMeasureLayer(\r\n    doc: jsPDF,\r\n    map: IgoMap,\r\n    margins: Array<number>\r\n  ) {\r\n    if (\r\n      map.layers.find(\r\n        (layer) => layer.visible && layer.id.startsWith('igo-measures-')\r\n      )\r\n    ) {\r\n      let canvasOverlayHTMLMeasures;\r\n      const mapOverlayMeasuresHTML = map.ol.getOverlayContainer();\r\n      await html2canvas(mapOverlayMeasuresHTML, {\r\n        scale: 1,\r\n        backgroundColor: null\r\n      }).then((e) => {\r\n        canvasOverlayHTMLMeasures = e;\r\n      });\r\n      this.addCanvas(doc, canvasOverlayHTMLMeasures, margins); // this adds measure overlays\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get html code for all layers legend\r\n   * @param  map IgoMap\r\n   * @param  width The width that the legend need to be\r\n   * @return Html code for the legend\r\n   */\r\n  getLayersLegendHtml(\r\n    map: IgoMap,\r\n    width: number,\r\n    resolution: number\r\n  ): Observable<string> {\r\n    return new Observable((observer) => {\r\n      let html = '';\r\n      const legends = getLayersLegends(map.layers, {\r\n        resolution: map.viewController.getResolution(),\r\n        extent: map.viewController.getExtent(),\r\n        projection: map.viewController.getOlProjection().getCode(),\r\n        // scale: map.viewController.getScale(resolution),\r\n        size: map.ol.getSize()\r\n      } as LegendMapViewOptions);\r\n\r\n      if (legends.filter((l) => l.display === true).length === 0) {\r\n        observer.next(html);\r\n        observer.complete();\r\n        return;\r\n      }\r\n      // Define important style to be sure that all container is convert\r\n      // to image not just visible part\r\n      html += '<style media=\"screen\" type=\"text/css\">';\r\n      html +=\r\n        '.html2canvas-container { width: ' +\r\n        width +\r\n        'mm !important; height: 2000px !important; }';\r\n      html += 'table.tableLegend {table-layout: auto;}';\r\n      html +=\r\n        'div.styleLegend {padding-top: 5px; padding-right:5px;padding-left:5px;padding-bottom:5px;}';\r\n      html += '</style>';\r\n      // The font size will also be lowered afterwards (globally along the legend size)\r\n      // this allows having a good relative font size here and to keep ajusting the legend size\r\n      // while keeping good relative font size\r\n      html += '<font size=\"3\" face=\"Times\" >';\r\n      html += '<div class=\"styleLegend\">';\r\n      html += '<table class=\"tableLegend\" >';\r\n\r\n      // For each legend, define an html table cell\r\n      const images$ = legends\r\n        .filter((l) => l.display && l.isInResolutionsRange === true)\r\n        .map((legend) =>\r\n          this.getDataImage(legend.url).pipe(\r\n            rxMap((dataImage) => {\r\n              let htmlImg =\r\n                '<tr><td>' + legend.title.toUpperCase() + '</td></tr>';\r\n              htmlImg += '<tr><td><img src=\"' + dataImage + '\"></td></tr>';\r\n              return htmlImg;\r\n            })\r\n          )\r\n        );\r\n      forkJoin(images$).subscribe((dataImages) => {\r\n        html = dataImages.reduce((acc, current) => (acc += current), html);\r\n        html += '</table>';\r\n        html += '</div>';\r\n        observer.next(html);\r\n        observer.complete();\r\n      });\r\n    });\r\n  }\r\n\r\n  getDataImage(url: string): Observable<string> {\r\n    const secureIMG = new SecureImagePipe(this.http, this.configService);\r\n    return secureIMG.transform(url);\r\n  }\r\n\r\n  /**\r\n   * Get all the legend in a single image\r\n   * * @param  format - Image format. default value to \"png\"\r\n   * @return The image of the legend\r\n   */\r\n  async getLayersLegendImage(\r\n    map,\r\n    format: string = 'png',\r\n    doZipFile: boolean,\r\n    resolution: number\r\n  ) {\r\n    const status$ = new Subject();\r\n    // Get html code for the legend\r\n    const width = 200; // milimeters unit, originally define for document pdf\r\n    let html = await this.getLayersLegendHtml(\r\n      map,\r\n      width,\r\n      resolution\r\n    ).toPromise();\r\n    format = format.toLowerCase();\r\n\r\n    // If no legend show No LEGEND in an image\r\n    if (html.length === 0) {\r\n      html = '<font size=\"12\" face=\"Courier New\" >';\r\n      html += '<div align=\"center\"><b>NO LEGEND</b></div>';\r\n    }\r\n    // Create div to contain html code for legend\r\n    const div = window.document.createElement('div');\r\n    div.style.position = 'absolute';\r\n    div.style.top = '0';\r\n    div.style.zIndex = '-1';\r\n    // Add html code to convert in the new window\r\n    window.document.body.appendChild(div);\r\n    div.innerHTML = html;\r\n\r\n    await this.timeout(1);\r\n    const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {\r\n      console.log(e);\r\n    });\r\n    this.removeHtmlElement(div);\r\n    if (canvas) {\r\n      let status = SubjectStatus.Done;\r\n      try {\r\n        if (!doZipFile) {\r\n          // Save the canvas as file\r\n          this.saveCanvasImageAsFile(canvas, 'legendImage', format);\r\n        } else {\r\n          // Add the canvas to zip\r\n          this.generateCanvaFileToZip(canvas, 'legendImage' + '.' + format);\r\n        }\r\n      } catch (err) {\r\n        status = SubjectStatus.Error;\r\n      }\r\n      status$.next(status);\r\n    }\r\n\r\n    return status$;\r\n  }\r\n\r\n  private removeHtmlElement(element: HTMLElement) {\r\n    element.parentNode.removeChild(element);\r\n  }\r\n\r\n  getTextPdfObjectSizeAndMarg(\r\n    text: string,\r\n    margins,\r\n    font: string,\r\n    fontSizeInPt: number,\r\n    fontStyle: string,\r\n    doc: jsPDF\r\n  ): TextPdfSizeAndMargin {\r\n    const pdfResolution = 96;\r\n    const docWidth = doc.internal.pageSize.getWidth();\r\n    const pageWidth = docWidth - margins[1] - margins[3];\r\n\r\n    // important to set it first, the textDimension change when font change!\r\n    doc.setFont(font, fontStyle);\r\n    doc.setFontSize(fontSizeInPt);\r\n\r\n    let textDimensions = doc.getTextDimensions(text);\r\n    let textMarginLeft: number;\r\n\r\n    if (textDimensions.w > pageWidth) {\r\n      // if the text is to long, reduce fontSize 70% and the overflow with be cut in print...\r\n      textMarginLeft = 0;\r\n      fontSizeInPt = fontSizeInPt * 0.7;\r\n      doc.setFontSize(fontSizeInPt);\r\n      textDimensions = doc.getTextDimensions(text);\r\n    } else {\r\n      textMarginLeft = (pageWidth - textDimensions.w) / 2;\r\n    }\r\n\r\n    return {\r\n      fontSize: fontSizeInPt,\r\n      marginLeft: textMarginLeft,\r\n      height: textDimensions.h\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Add comment to the document\r\n   * * @param  doc - pdf document\r\n   * * @param  comment - Comment to add in the document\r\n   */\r\n  private addComment(doc: jsPDF, comment: string) {\r\n    const commentMarginLeft = 10; //margin left and bottom is fix\r\n    const commentMarginBottom = 10;\r\n    const marginTop = doc.internal.pageSize.height - commentMarginBottom;\r\n    this.addTextInPdfDoc(\r\n      doc,\r\n      comment,\r\n      this.TEXTPDFFONT.commentFont,\r\n      this.TEXTPDFFONT.commentFontStyle,\r\n      this.TEXTPDFFONT.commentFontSize,\r\n      commentMarginLeft,\r\n      marginTop,\r\n      true\r\n    );\r\n  }\r\n\r\n  private addTextInPdfDoc(\r\n    doc: jsPDF,\r\n    textToAdd: string,\r\n    textFont: string,\r\n    textFontStyle: string,\r\n    textFontSize: number,\r\n    textMarginLeft: number,\r\n    textMarginTop: number,\r\n    isComment: boolean = false\r\n  ) {\r\n    doc.setFont(textFont, textFontStyle);\r\n    doc.setFontSize(textFontSize);\r\n\r\n    if (isComment) {\r\n      textToAdd = doc.splitTextToSize(\r\n        textToAdd,\r\n        doc.internal.pageSize.getWidth() - textMarginLeft * 3\r\n      );\r\n    }\r\n    doc.text(textToAdd, textMarginLeft, textMarginTop);\r\n  }\r\n\r\n  /**\r\n   * Add projection and/or scale to the document\r\n   * @param  doc - pdf document\r\n   * @param  map - Map of the app\r\n   * @param  dpi - DPI resolution of the document\r\n   * @param  projection - Bool to indicate if projection need to be added\r\n   * @param  scale - Bool to indicate if scale need to be added\r\n   */\r\n  private addProjScale(\r\n    doc: jsPDF,\r\n    map: IgoMap,\r\n    dpi: number,\r\n    projection: boolean,\r\n    scale: boolean\r\n  ) {\r\n    const translate = this.languageService.translate;\r\n    const projScaleSize = 12;\r\n    const projScaleMarginLeft = 10;\r\n    const marginBottom = 15;\r\n    const heightPixels = doc.internal.pageSize.height - marginBottom;\r\n\r\n    let textProjScale: string = '';\r\n    if (projection === true) {\r\n      const projText = translate.instant('igo.geo.printForm.projection');\r\n      textProjScale += projText + ': ' + map.projection;\r\n    }\r\n    if (scale === true) {\r\n      if (projection === true) {\r\n        textProjScale += '   ';\r\n      }\r\n      const scaleText = translate.instant('igo.geo.printForm.scale');\r\n      const mapScale = map.viewController.getScale(dpi);\r\n      textProjScale += scaleText + ': ~ 1 / ' + formatScale(mapScale);\r\n    }\r\n    doc.setFont('courier');\r\n    doc.setFontSize(projScaleSize);\r\n    doc.text(textProjScale, projScaleMarginLeft, heightPixels);\r\n  }\r\n\r\n  /**\r\n   * Add the legend to the document\r\n   * @param  doc - Pdf document where legend will be added\r\n   * @param  map - Map of the app\r\n   * @param  margins - Page margins\r\n   */\r\n  private async addLegend(\r\n    doc: jsPDF,\r\n    map: IgoMap,\r\n    margins: Array<number>,\r\n    resolution: number\r\n  ) {\r\n    // Get html code for the legend\r\n    const width = doc.internal.pageSize.width;\r\n    const html = await this.getLayersLegendHtml(\r\n      map,\r\n      width,\r\n      resolution\r\n    ).toPromise();\r\n    // If no legend, save the map directly\r\n    if (html === '') {\r\n      await this.saveDoc(doc);\r\n      return true;\r\n    }\r\n    // Create div to contain html code for legend\r\n    const div = window.document.createElement('div');\r\n    div.style.position = 'absolute';\r\n    div.style.top = '0';\r\n    div.style.zIndex = '-1';\r\n\r\n    // Add html code to convert in the new window\r\n    window.document.body.appendChild(div);\r\n    div.innerHTML = html;\r\n\r\n    await this.timeout(1);\r\n    const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {\r\n      console.log(e);\r\n    });\r\n    this.removeHtmlElement(div);\r\n    if (canvas) {\r\n      const pourcentageReduction = 0.85;\r\n      const imageSize = [\r\n        (pourcentageReduction * (25.4 * canvas.width)) / resolution,\r\n        (pourcentageReduction * (25.4 * canvas.height)) / resolution\r\n      ];\r\n      let imgData;\r\n      doc.addPage();\r\n      imgData = canvas.toDataURL('image/png');\r\n      doc.addImage(imgData, 'PNG', 10, 10, imageSize[0], imageSize[1]);\r\n    }\r\n\r\n    await this.saveDoc(doc);\r\n  }\r\n\r\n  /**\r\n   * Add the legend to the document\r\n   * @param  doc - Pdf document where legend will be added\r\n   * @param  map - Map of the app\r\n   * @param  margins - Page margins\r\n   */\r\n  private async addLegendSamePage(\r\n    doc: jsPDF,\r\n    map: IgoMap,\r\n    margins: Array<number>,\r\n    resolution: number,\r\n    legendPosition: string\r\n  ) {\r\n    // Get html code for the legend\r\n    const width = doc.internal.pageSize.width;\r\n    const html = await this.getLayersLegendHtml(\r\n      map,\r\n      width,\r\n      resolution\r\n    ).toPromise();\r\n    // If no legend, save the map directly\r\n    if (html === '') {\r\n      await this.saveDoc(doc);\r\n      return true;\r\n    }\r\n    // Create div to contain html code for legend\r\n    const div = window.document.createElement('div');\r\n    div.style.position = 'absolute';\r\n    div.style.top = '0';\r\n    div.style.zIndex = '-1';\r\n    // Add html code to convert in the new window\r\n    window.document.body.appendChild(div);\r\n    div.innerHTML = html;\r\n    await this.timeout(1);\r\n    const canvas = await html2canvas(div, { useCORS: true }).catch((e) => {\r\n      console.log(e);\r\n    });\r\n    this.removeHtmlElement(div);\r\n    let marginsLegend;\r\n    if (canvas) {\r\n      const pourcentageReduction = 0.85;\r\n      const imageSize = [\r\n        (pourcentageReduction * (25.4 * canvas.width)) / resolution,\r\n        (pourcentageReduction * (25.4 * canvas.height)) / resolution\r\n      ];\r\n      // Move the legend to the correct position on the page\r\n      if (legendPosition === 'bottomright') {\r\n        marginsLegend = [\r\n          doc.internal.pageSize.height - margins[2] - imageSize[1],\r\n          margins[1],\r\n          margins[2],\r\n          doc.internal.pageSize.width - margins[1] - imageSize[0]\r\n        ];\r\n      } else if (legendPosition === 'topright') {\r\n        marginsLegend = [\r\n          margins[0],\r\n          margins[1],\r\n          doc.internal.pageSize.height - margins[0] - imageSize[1],\r\n          doc.internal.pageSize.width - margins[1] - imageSize[0]\r\n        ];\r\n      } else if (legendPosition === 'bottomleft') {\r\n        // When the legend is in the bottom left, raise the legend slightly upward so that attributions are visible\r\n        marginsLegend = [\r\n          doc.internal.pageSize.height - margins[2] - imageSize[1] - 15,\r\n          doc.internal.pageSize.width - margins[3] - imageSize[0],\r\n          margins[2] + 15,\r\n          margins[3]\r\n        ];\r\n      } else if (legendPosition === 'topleft') {\r\n        marginsLegend = [\r\n          margins[0],\r\n          doc.internal.pageSize.width - margins[3] - imageSize[0],\r\n          doc.internal.pageSize.height - margins[0] - imageSize[1],\r\n          margins[3]\r\n        ];\r\n      }\r\n      this.addCanvas(doc, canvas, marginsLegend); // this adds the legend\r\n      await this.saveDoc(doc);\r\n    }\r\n  }\r\n\r\n  defineNbFileToProcess(nbFileToProcess) {\r\n    this.nbFileToProcess = nbFileToProcess;\r\n  }\r\n\r\n  private timeout(ms) {\r\n    return new Promise((resolve) => setTimeout(resolve, ms));\r\n  }\r\n\r\n  private addCanvas(\r\n    doc: jsPDF,\r\n    canvas: HTMLCanvasElement,\r\n    margins: Array<number>\r\n  ) {\r\n    let image;\r\n    if (canvas) {\r\n      image = canvas.toDataURL('image/png');\r\n    }\r\n\r\n    if (image !== undefined) {\r\n      if (image.length < 20) {\r\n        console.log('Warning: An image cannot be print in pdf file');\r\n        return;\r\n      }\r\n      const imageSize = this.getImageSizeToFitPdf(doc, canvas, margins);\r\n      doc.addImage(\r\n        image,\r\n        'PNG',\r\n        margins[3],\r\n        margins[0],\r\n        imageSize[0],\r\n        imageSize[1]\r\n      );\r\n\r\n      doc.rect(margins[3], margins[0], imageSize[0], imageSize[1]);\r\n\r\n      this.imgSizeAdded = imageSize; // keep img size for georef later\r\n    }\r\n  }\r\n\r\n  // TODO fix printing with image resolution\r\n  addMap(\r\n    doc: jsPDF,\r\n    map: IgoMap,\r\n    resolution: number,\r\n    docSize: [number, number],\r\n    margins: Array<number>,\r\n    legendPostion: PrintLegendPosition\r\n  ) {\r\n    const mapSize = map.ol.getSize() as [number, number];\r\n    const viewResolution = map.ol.getView().getResolution();\r\n    const dimensionPixels = this.setMapResolution(\r\n      map,\r\n      docSize,\r\n      resolution,\r\n      viewResolution\r\n    );\r\n    const status$ = new Subject();\r\n\r\n    let timeout;\r\n    map.ol.once('rendercomplete', async (event: any) => {\r\n      const mapCanvas = event.target\r\n        .getViewport()\r\n        .getElementsByTagName('canvas') as HTMLCollectionOf<HTMLCanvasElement>;\r\n      const mapResultCanvas = await this.drawMap(dimensionPixels, mapCanvas);\r\n\r\n      this.resetOriginalMapSize(map, mapSize, viewResolution);\r\n\r\n      await this.drawMapControls(map, mapResultCanvas, legendPostion);\r\n\r\n      const mapStatus$$ = map.status$.subscribe((mapStatus: SubjectStatus) => {\r\n        clearTimeout(timeout);\r\n        if (mapStatus !== SubjectStatus.Done) {\r\n          return;\r\n        }\r\n        mapStatus$$.unsubscribe();\r\n        let status = SubjectStatus.Done;\r\n        try {\r\n          if (mapResultCanvas.width !== 0) {\r\n            this.addCanvas(doc, mapResultCanvas, margins);\r\n          }\r\n        } catch (err) {\r\n          status = SubjectStatus.Error;\r\n          this.messageService.error(\r\n            'igo.geo.printForm.corsErrorMessageBody',\r\n            'igo.geo.printForm.corsErrorMessageHeader'\r\n          );\r\n        }\r\n        status$.next(status);\r\n      });\r\n\r\n      // If no loading as started after 200ms, then probably no loading\r\n      // is required.\r\n      timeout = window.setTimeout(() => {\r\n        mapStatus$$.unsubscribe();\r\n\r\n        let status = SubjectStatus.Done;\r\n        try {\r\n          if (mapResultCanvas.width !== 0) {\r\n            this.addCanvas(doc, mapResultCanvas, margins);\r\n          }\r\n        } catch (err) {\r\n          status = SubjectStatus.Error;\r\n          this.messageService.error(\r\n            'igo.geo.printForm.corsErrorMessageBody',\r\n            'igo.geo.printForm.corsErrorMessageHeader'\r\n          );\r\n        }\r\n        this.resetOriginalMapSize(map, mapSize, viewResolution);\r\n        status$.next(status);\r\n      }, 200);\r\n    });\r\n\r\n    return status$;\r\n  }\r\n\r\n  private setMapResolution(\r\n    map: IgoMap,\r\n    initialSize: [number, number],\r\n    resolution: number,\r\n    viewResolution: number\r\n  ): [number, number] {\r\n    const mapSize = map.ol.getSize();\r\n    const widthPixels = Math.round((initialSize[0] * resolution) / 25.4);\r\n    const heightPixels = Math.round((initialSize[1] * resolution) / 25.4);\r\n\r\n    // Set print size\r\n    const printSize = [widthPixels, heightPixels];\r\n    map.ol.setSize(printSize);\r\n    const scaling = Math.min(\r\n      widthPixels / mapSize[0],\r\n      heightPixels / mapSize[1]\r\n    );\r\n    map.ol.getView().setResolution(viewResolution / scaling);\r\n\r\n    return [widthPixels, heightPixels];\r\n  }\r\n\r\n  private resetOriginalMapSize(\r\n    map: IgoMap,\r\n    initialSize: [number, number],\r\n    viewResolution: number\r\n  ) {\r\n    map.ol.setSize(initialSize);\r\n    map.ol.getView().setResolution(viewResolution);\r\n    map.ol.updateSize();\r\n    map.ol.renderSync();\r\n  }\r\n\r\n  async drawMap(\r\n    size: Array<number>,\r\n    mapCanvas: HTMLCollectionOf<HTMLCanvasElement>\r\n  ): Promise<HTMLCanvasElement> {\r\n    const mapResultCanvas = document.createElement('canvas');\r\n    mapResultCanvas.width = size[0];\r\n    mapResultCanvas.height = size[1];\r\n\r\n    for (let index = 0; index < mapCanvas.length; index++) {\r\n      const canvas = mapCanvas[index];\r\n      if (canvas.width > 0) {\r\n        this.handleCanvas(canvas, mapResultCanvas);\r\n      }\r\n    }\r\n    return mapResultCanvas;\r\n  }\r\n\r\n  private handleCanvas(\r\n    canvas: HTMLCanvasElement,\r\n    mapResultCanvas: HTMLCanvasElement\r\n  ) {\r\n    const mapContextResult = mapResultCanvas.getContext('2d');\r\n    const opacity = canvas.parentElement.style.opacity || canvas.style.opacity;\r\n    mapContextResult.globalAlpha = opacity === '' ? 1 : Number(opacity);\r\n    const transform = canvas.style.transform;\r\n    let matrix: number[];\r\n    if (transform) {\r\n      // Get the transform parameters from the style's transform matrix\r\n      matrix = transform\r\n        .match(/^matrix\\(([^\\(]*)\\)$/)[1]\r\n        .split(',')\r\n        .map(Number);\r\n    } else {\r\n      matrix = [\r\n        parseFloat(canvas.style.width) / canvas.width,\r\n        0,\r\n        0,\r\n        parseFloat(canvas.style.height) / canvas.height,\r\n        0,\r\n        0\r\n      ];\r\n    }\r\n    CanvasRenderingContext2D.prototype.setTransform.apply(\r\n      mapContextResult,\r\n      matrix\r\n    );\r\n    const backgroundColor = canvas.parentElement.style.backgroundColor;\r\n    if (backgroundColor) {\r\n      mapContextResult.fillStyle = backgroundColor;\r\n      mapContextResult.fillRect(0, 0, canvas.width, canvas.height);\r\n    }\r\n    mapContextResult.drawImage(canvas, 0, 0);\r\n    mapContextResult.globalAlpha = 1;\r\n    // reset canvas transform to initial\r\n    mapContextResult.setTransform(1, 0, 0, 1, 0, 0);\r\n  }\r\n\r\n  async drawMapControls(\r\n    map: IgoMap,\r\n    canvas: HTMLCanvasElement,\r\n    position: PrintLegendPosition\r\n  ): Promise<void> {\r\n    const context = canvas.getContext('2d');\r\n    // Get the scale and attribution\r\n    // we use cloneNode to modify the nodes to print without modifying it on the page, using deep:true to get children\r\n    const mapOverlayHTML = map.ol\r\n      .getOverlayContainerStopEvent()\r\n      .cloneNode(true) as HTMLElement;\r\n    // add North Direction to mapOverly\r\n    await this.addNorthDirection(mapOverlayHTML, position);\r\n    // add map Attribution designe to print\r\n    await this.addAttribution(mapOverlayHTML);\r\n\r\n    // set 'OverlayContainer' size to print size\r\n    mapOverlayHTML.style.width = canvas.width + 'px';\r\n    mapOverlayHTML.style.height = canvas.height + 'px';\r\n    // we add zindex -1 to not show modification to the user\r\n    mapOverlayHTML.style.zIndex = '-1';\r\n    // and make sure html2canvas to render the image correctly\r\n    document\r\n      .getElementsByClassName('ol-viewport')[0]\r\n      .appendChild(mapOverlayHTML);\r\n    // Change the styles of hyperlink in the printed version\r\n    // Transform the Overlay into a canvas\r\n    // scale is necessary to make it in google chrome\r\n    // background as null because otherwise it is white and cover the map\r\n    // allowtaint is to allow rendering images in the attributions\r\n    // useCORS: true pour permettre de renderer les images (ne marche pas en local)\r\n    const canvasOverlayHTML = await html2canvas(mapOverlayHTML, {\r\n      scale: 1,\r\n      backgroundColor: null,\r\n      allowTaint: true,\r\n      useCORS: true\r\n    });\r\n\r\n    context.drawImage(canvasOverlayHTML, 0, 0);\r\n    // remove 'mapOverlayHTML' after generating canvas\r\n    mapOverlayHTML.remove();\r\n  }\r\n\r\n  private async addNorthDirection(\r\n    mapOverlayHTML: HTMLElement,\r\n    position: PrintLegendPosition\r\n  ): Promise<void> {\r\n    const northDirection = document\r\n      .getElementsByTagName('igo-rotation-button')[0]\r\n      .cloneNode(true) as HTMLElement;\r\n    const HTMLButton = northDirection.getElementsByTagName(\r\n      'button'\r\n    )[0] as HTMLElement;\r\n    if (!HTMLButton) {\r\n      return null;\r\n    }\r\n    // in case legend position is topright\r\n    // we change rotate btn to topleft\r\n    if (position === 'topright') {\r\n      northDirection.style.width = 'inherit';\r\n      northDirection.style.left = '10px';\r\n    }\r\n    HTMLButton.parentElement.style.background = 'transparent';\r\n    HTMLButton.style.color = '#000';\r\n    mapOverlayHTML.appendChild(northDirection);\r\n  }\r\n\r\n  private async addAttribution(mapOverlayHTML: HTMLElement): Promise<void> {\r\n    const HTMLattribution =\r\n      mapOverlayHTML.getElementsByClassName('ol-attribution')[0];\r\n    const HTMLButton = HTMLattribution.getElementsByTagName('button')[0];\r\n    if (!HTMLButton) {\r\n      return null;\r\n    }\r\n    HTMLButton.setAttribute('data-html2canvas-ignore', 'true');\r\n    const olCollapsed: boolean =\r\n      HTMLattribution.classList.contains('ol-collapsed');\r\n    if (olCollapsed) {\r\n      HTMLattribution.classList.remove('ol-collapsed');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Download an image of the map with addition of informations\r\n   * @param  map - Map of the app\r\n   * @param  format - Image format. default value to \"png\"\r\n   * @param  projection - Indicate if projection need to be add. Default to false\r\n   * @param  scale - Indicate if scale need to be add. Default to false\r\n   * @param  legend - Indicate if the legend of layers need to be download. Default to false\r\n   * @param  title - Title to add for the map - Default to blank\r\n   * @param  subtitle - Subtitle to add for the map - Default to blank\r\n   * @param  comment - Comment to add for the map - Default to blank\r\n   * @param  doZipFile - Indicate if we do a zip with the file\r\n   * @return Image file of the map with extension format given as parameter\r\n   */\r\n  downloadMapImage(\r\n    map: IgoMap,\r\n    printResolution: PrintResolution,\r\n    format = 'png',\r\n    projection = false,\r\n    scale = false,\r\n    title = '',\r\n    subtitle = '',\r\n    comment = '',\r\n    doZipFile = true,\r\n    legendPosition: PrintLegendPosition\r\n  ) {\r\n    const status$ = new Subject();\r\n    this.activityId = this.activityService.register();\r\n    const translate = this.languageService.translate;\r\n    format = format.toLowerCase();\r\n    const resolution = +printResolution;\r\n    const initialMapSize = map.ol.getSize() as [number, number];\r\n    const viewResolution = map.ol.getView().getResolution();\r\n\r\n    map.ol.once('rendercomplete', async (event: any) => {\r\n      const size = map.ol.getSize();\r\n      const mapCanvas = event.target\r\n        .getViewport()\r\n        .getElementsByTagName('canvas') as HTMLCollectionOf<HTMLCanvasElement>;\r\n      const mapResultCanvas = await this.drawMap(size, mapCanvas);\r\n\r\n      this.resetOriginalMapSize(map, initialMapSize, viewResolution);\r\n\r\n      await this.drawMapControls(map, mapResultCanvas, legendPosition);\r\n      // Check the legendPosition\r\n      if (legendPosition !== 'none') {\r\n        if (\r\n          ['topleft', 'topright', 'bottomleft', 'bottomright'].indexOf(\r\n            legendPosition\r\n          ) > -1\r\n        ) {\r\n          await this.addLegendToImage(\r\n            mapResultCanvas,\r\n            map,\r\n            resolution,\r\n            legendPosition,\r\n            format\r\n          );\r\n        } else if (legendPosition === 'newpage') {\r\n          await this.getLayersLegendImage(map, format, doZipFile, resolution);\r\n        }\r\n      }\r\n      // add other information to final canvas before exporting\r\n      const newCanvas = document.createElement('canvas');\r\n      const newContext = newCanvas.getContext('2d');\r\n      // Postion in height to set the canvas in new canvas\r\n      let positionHCanvas = 0;\r\n      // Get height/width of map canvas\r\n      const width = mapResultCanvas.width;\r\n      let height = mapResultCanvas.height;\r\n      // Set Font to calculate comment width\r\n      newContext.font = '20px Calibri';\r\n      const commentWidth = newContext.measureText(comment).width;\r\n      // Add height for title if defined\r\n      height = title !== '' ? height + 30 : height;\r\n      // Add height for title if defined\r\n      height = subtitle !== '' ? height + 30 : height;\r\n      // Add height for projection or scale (same line) if defined\r\n      height = projection !== false || scale !== false ? height + 30 : height;\r\n      const positionHProjScale = height - 10;\r\n      // Define number of line depending of the comment length\r\n      const commentNbLine = Math.ceil(commentWidth / width);\r\n      // Add height for multiline comment if defined\r\n      height = comment !== '' ? height + commentNbLine * 30 : height;\r\n      let positionHComment = height - commentNbLine * 20 + 5;\r\n      // Set the new canvas with the new calculated size\r\n      newCanvas.width = width;\r\n      newCanvas.height = height;\r\n\r\n      if (['bmp', 'gif', 'jpeg', 'png', 'tiff'].indexOf(format) > -1) {\r\n        // Patch Jpeg default black background to white\r\n        if (\r\n          format === 'jpeg' ||\r\n          title !== '' ||\r\n          subtitle !== '' ||\r\n          comment !== '' ||\r\n          projection !== false ||\r\n          scale !== false\r\n        ) {\r\n          newContext.fillStyle = '#ffffff';\r\n          newContext.fillRect(0, 0, width, height);\r\n          newContext.fillStyle = '#000000';\r\n        }\r\n      }\r\n      // If a title need to be added to canvas\r\n      if (title !== '') {\r\n        // Set font for title\r\n        // Adjust according to title length\r\n        newContext.font = '26px Calibri';\r\n        positionHCanvas = 30;\r\n        newContext.textAlign = 'center';\r\n        newContext.fillText(title, width / 2, 20, width * 0.9);\r\n      }\r\n\r\n      if (subtitle !== '') {\r\n        // Set font for subtitle\r\n        // Adjust according to title length\r\n        newContext.font = '26px Calibri';\r\n        positionHCanvas = 60;\r\n        newContext.textAlign = 'center';\r\n        newContext.fillText(subtitle, width / 2, 50, width * 0.9);\r\n      }\r\n\r\n      // Set font for next section\r\n      newContext.font = '20px Calibri';\r\n      // If projection or/end scale need to be added to canvas\r\n      if (projection !== false || scale !== false) {\r\n        let projectionScaleText = '';\r\n        if (projection !== false) {\r\n          const projText = translate.instant('igo.geo.printForm.projection');\r\n          projectionScaleText = projText + ': ' + map.projection + '         ';\r\n        }\r\n\r\n        if (scale !== false) {\r\n          const scaleText = translate.instant('igo.geo.printForm.scale');\r\n          const mapScale = map.viewController.getScale(resolution);\r\n          projectionScaleText += scaleText + ': ~ 1 / ' + formatScale(mapScale);\r\n        }\r\n        newContext.textAlign = 'center';\r\n        newContext.fillText(\r\n          projectionScaleText,\r\n          width / 2,\r\n          positionHProjScale,\r\n          width * 0.9\r\n        );\r\n      }\r\n\r\n      // If a comment need to be added to canvas\r\n      if (comment !== '') {\r\n        newContext.textAlign = 'center';\r\n        // If only one line, no need to multiline the comment\r\n        if (commentNbLine === 1) {\r\n          newContext.fillText(comment, width / 2, positionHComment);\r\n        } else {\r\n          // Separate the setenses to be approx. the same length\r\n          const nbCommentChar = comment.length;\r\n          const CommentLengthToCut = Math.floor(nbCommentChar / commentNbLine);\r\n          let commentCurrentLine = '';\r\n          let positionFirstCutChar = 0;\r\n          let positionLastBlank;\r\n          // Loop for the number of line calculated\r\n          for (let i = 0; i < commentNbLine; i++) {\r\n            // For all line except last\r\n            if (commentNbLine - 1 > i) {\r\n              // Get comment current line to find the right place tu cut comment\r\n              commentCurrentLine = comment.substr(\r\n                positionFirstCutChar,\r\n                CommentLengthToCut\r\n              );\r\n              // Cut the setence at blank\r\n              positionLastBlank = commentCurrentLine.lastIndexOf(' ');\r\n              newContext.fillText(\r\n                commentCurrentLine.substr(0, positionLastBlank),\r\n                width / 2,\r\n                positionHComment\r\n              );\r\n              positionFirstCutChar += positionLastBlank;\r\n              // Go to next line for insertion\r\n              positionHComment += 20;\r\n            } else {\r\n              // Don't cut last part\r\n              newContext.fillText(\r\n                comment.substr(positionFirstCutChar),\r\n                width / 2,\r\n                positionHComment\r\n              );\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      newContext.drawImage(mapResultCanvas, 0, positionHCanvas);\r\n\r\n      let status = SubjectStatus.Done;\r\n      let fileNameWithExt = 'map.' + format;\r\n      if (format.toLowerCase() === 'tiff') {\r\n        fileNameWithExt =\r\n          'map' + map.projection.replace(':', '_') + '.' + format;\r\n      }\r\n\r\n      try {\r\n        // Save the canvas as file\r\n        if (!doZipFile) {\r\n          this.saveCanvasImageAsFile(newCanvas, fileNameWithExt, format);\r\n        } else if (format.toLowerCase() === 'tiff') {\r\n          // Add the canvas to zip\r\n          this.generateCanvaFileToZip(newCanvas, fileNameWithExt);\r\n        } else {\r\n          // Add the canvas to zip\r\n          this.generateCanvaFileToZip(newCanvas, fileNameWithExt);\r\n        }\r\n      } catch (err) {\r\n        status = SubjectStatus.Error;\r\n      }\r\n      status$.next(status);\r\n\r\n      if (format.toLowerCase() === 'tiff') {\r\n        const tfwFileNameWithExt =\r\n          fileNameWithExt.substring(\r\n            0,\r\n            fileNameWithExt.toLowerCase().indexOf('.tiff')\r\n          ) + '.tfw';\r\n        const tiwContent = this.getWorldFileInformation(map);\r\n        const blob = new Blob([tiwContent], {\r\n          type: 'text/plain;charset=utf-8'\r\n        });\r\n        if (!doZipFile) {\r\n          // saveAs automaticly replace ':' for '_'\r\n          saveAs(blob, tfwFileNameWithExt);\r\n          this.saveFileProcessing();\r\n        } else {\r\n          // Add the canvas to zip\r\n          this.addFileToZip(tfwFileNameWithExt, blob);\r\n        }\r\n      }\r\n    });\r\n\r\n    this.setMapImageResolution(map, initialMapSize, resolution, viewResolution);\r\n\r\n    return status$;\r\n  }\r\n\r\n  private setMapImageResolution(\r\n    map: IgoMap,\r\n    initialMapSize: [number, number],\r\n    resolution: number,\r\n    viewResolution: number\r\n  ): void {\r\n    const scaleFactor = resolution / 96;\r\n    const newMapSize = [\r\n      Math.round(initialMapSize[0] * scaleFactor), // width\r\n      Math.round(initialMapSize[1] * scaleFactor) // height\r\n    ];\r\n    map.ol.setSize(newMapSize);\r\n    const scaling = Math.min(\r\n      newMapSize[0] / initialMapSize[0],\r\n      newMapSize[1] / initialMapSize[1]\r\n    );\r\n    const view = map.ol.getView();\r\n    view.setResolution(viewResolution / scaling);\r\n    map.ol.renderSync();\r\n  }\r\n\r\n  /**\r\n   * Create and Add Legend to the map canvas\r\n   * @param  canvas Canvas of the map\r\n   * @param  map Map of the app\r\n   * @param  resolution Resolution of map\r\n   * @param  legendPosition Legend position\r\n   * @param  format Image format\r\n   */\r\n  private async addLegendToImage(\r\n    canvas: HTMLCanvasElement,\r\n    map: IgoMap,\r\n    resolution: number,\r\n    legendPosition: string,\r\n    format: string\r\n  ) {\r\n    const fileNameWithExt = 'map.' + format;\r\n    const context = canvas.getContext('2d');\r\n\r\n    // Get html code for the legend\r\n    const html = await this.getLayersLegendHtml(\r\n      map,\r\n      canvas.width,\r\n      resolution\r\n    ).toPromise();\r\n    // If no legend, save the map directly\r\n    if (html === '') {\r\n      await this.saveCanvasImageAsFile(canvas, fileNameWithExt, format);\r\n      return true;\r\n    }\r\n    // Create div to contain html code for legend\r\n    const div = window.document.createElement('div');\r\n    div.style.position = 'absolute';\r\n    div.style.top = '0';\r\n    div.style.zIndex = '-1';\r\n    // Add html code to convert in the new window\r\n    window.document.body.appendChild(div);\r\n    div.innerHTML = html;\r\n    await this.timeout(1);\r\n    const canvasLegend = await html2canvas(div, { useCORS: true }).catch(\r\n      (e) => {\r\n        console.log(e);\r\n      }\r\n    );\r\n\r\n    if (canvasLegend) {\r\n      const canvasHeight = canvas.height;\r\n      const canvasWidth = canvas.width;\r\n      const legendHeight = canvasLegend.height;\r\n      const legendWidth = canvasLegend.width;\r\n      // Move the legend to the correct position on the page\r\n      const offset = canvasHeight * 0.01;\r\n      let legendX: number;\r\n      let legendY: number;\r\n\r\n      if (legendPosition === 'bottomright') {\r\n        legendX = canvasWidth - legendWidth - offset;\r\n        legendY = canvasHeight - legendHeight - offset;\r\n      } else if (legendPosition === 'topright') {\r\n        legendX = canvasWidth - legendWidth - offset;\r\n        legendY = offset;\r\n      } else if (legendPosition === 'bottomleft') {\r\n        legendX = offset;\r\n        legendY = canvasHeight - legendHeight - offset - 15;\r\n      } else if (legendPosition === 'topleft') {\r\n        legendX = offset;\r\n        legendY = offset;\r\n      }\r\n\r\n      context.drawImage(\r\n        canvasLegend,\r\n        legendX,\r\n        legendY,\r\n        legendWidth,\r\n        legendHeight\r\n      );\r\n      context.strokeRect(legendX, legendY, legendWidth, legendHeight);\r\n      this.removeHtmlElement(div);\r\n      return true;\r\n    }\r\n  }\r\n\r\n  private renderMap(map, size, extent) {\r\n    map.ol.updateSize();\r\n    map.ol.renderSync();\r\n  }\r\n\r\n  /**\r\n   * Save document\r\n   * @param  doc - Document to save\r\n   */\r\n  protected async saveDoc(doc: jsPDF) {\r\n    await doc.save('map_georef.pdf', { returnPromise: true });\r\n  }\r\n\r\n  /**\r\n   * Calculate the best Image size to fit in pdf\r\n   * @param doc - Pdf Document\r\n   * @param canvas - Canvas of image\r\n   * @param margins - Page margins\r\n   */\r\n  getImageSizeToFitPdf(doc, canvas, margins) {\r\n    // Define variable to calculate best size to fit in one page\r\n    const pageHeight =\r\n      doc.internal.pageSize.getHeight() - (margins[0] + margins[2] + 10);\r\n    const pageWidth =\r\n      doc.internal.pageSize.getWidth() - (margins[1] + margins[3]);\r\n    const canHeight = this.pdf_units2points(canvas.height, 'mm');\r\n    const canWidth = this.pdf_units2points(canvas.width, 'mm');\r\n\r\n    const heightRatio = canHeight / pageHeight;\r\n    const widthRatio = canWidth / pageWidth;\r\n    const maxRatio = heightRatio > widthRatio ? heightRatio : widthRatio;\r\n    const imgHeigh = maxRatio > 1 ? canHeight / maxRatio : canHeight;\r\n    const imgWidth = maxRatio > 1 ? canWidth / maxRatio : canWidth;\r\n    return [imgWidth, imgHeigh];\r\n  }\r\n\r\n  /**\r\n   * Get a world file information for tiff\r\n   * @param  map - Map of the app\r\n   */\r\n  private getWorldFileInformation(map) {\r\n    const currentResolution = map.viewController.getResolution();\r\n    const currentExtent = map.viewController.getExtent(); // Return [minx, miny, maxx, maxy]\r\n    return [\r\n      currentResolution,\r\n      0,\r\n      0,\r\n      -currentResolution,\r\n      currentExtent[0] + currentResolution / 0.5,\r\n      currentExtent[3] - currentResolution / 0.5\r\n    ].join('\\n');\r\n  }\r\n\r\n  /**\r\n   * Save canvas image as file\r\n   * @param canvas - Canvas to save\r\n   * @param name - Name of the file\r\n   * @param format - file format\r\n   */\r\n  private saveCanvasImageAsFile(canvas, nameWithExt, format) {\r\n    const blobFormat = 'image/' + format;\r\n    const that = this;\r\n\r\n    try {\r\n      canvas.toDataURL(); // Just to make the catch trigger wihtout toBlob Error throw not catched\r\n      canvas.toBlob((blob) => {\r\n        // download image\r\n        saveAs(blob, nameWithExt);\r\n        that.saveFileProcessing();\r\n      }, blobFormat);\r\n    } catch (err) {\r\n      this.messageService.error(\r\n        'igo.geo.printForm.corsErrorMessageBody',\r\n        'igo.geo.printForm.corsErrorMessageHeader'\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add file to a zip\r\n   * @param canvas - File to add to the zip\r\n   * @param  name -Name of the fileoverview\r\n   */\r\n  private generateCanvaFileToZip(canvas, name) {\r\n    const blobFormat = 'image/' + 'jpeg';\r\n    const that = this;\r\n    if (\r\n      !this.hasOwnProperty('zipFile') ||\r\n      typeof this.zipFile === 'undefined'\r\n    ) {\r\n      this.zipFile = new JSZip();\r\n    }\r\n\r\n    try {\r\n      canvas.toDataURL(); // Just to make the catch trigger wihtout toBlob Error throw not catched\r\n      if (navigator.msSaveBlob) {\r\n        this.addFileToZip(name, canvas.msToBlob());\r\n      } else {\r\n        canvas.toBlob((blob) => {\r\n          that.addFileToZip(name, blob);\r\n        }, blobFormat);\r\n      }\r\n    } catch (err) {\r\n      this.messageService.error(\r\n        'igo.geo.printForm.corsErrorMessageBody',\r\n        'igo.geo.printForm.corsErrorMessageHeader'\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add file to zip, if all file are zipped, download\r\n   * @param name - Name of the files\r\n   * @param blob - Contain of file\r\n   */\r\n  private addFileToZip(name, blob) {\r\n    // add file to zip\r\n    this.zipFile.file(name, blob);\r\n    this.nbFileToProcess--;\r\n\r\n    // If all files are proccessed\r\n    if (this.nbFileToProcess === 0) {\r\n      // Download zip file\r\n      this.getZipFile();\r\n      // Stop loading\r\n      this.activityService.unregister(this.activityId);\r\n    }\r\n  }\r\n\r\n  private saveFileProcessing() {\r\n    this.nbFileToProcess--;\r\n\r\n    // If all files are proccessed\r\n    if (this.nbFileToProcess === 0) {\r\n      // Stop loading\r\n      this.activityService.unregister(this.activityId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the zipped file\r\n   * @return Retun a zip file\r\n   */\r\n  private getZipFile() {\r\n    const that = this;\r\n    this.zipFile.generateAsync({ type: 'blob' }).then((blob) => {\r\n      // 1) generate the zip file\r\n      saveAs(blob, 'map.zip');\r\n      delete that.zipFile;\r\n    });\r\n  }\r\n\r\n  private pdf_units2points(n, unit): number {\r\n    let k = 1;\r\n\r\n    // this code is borrowed from jsPDF\r\n    //  as it does not expose a public API\r\n    //  for converting units to points.\r\n    switch (unit) {\r\n      case 'pt':\r\n        k = 1;\r\n        break;\r\n      case 'mm':\r\n        k = 72 / 25.4;\r\n        break;\r\n      case 'cm':\r\n        k = 72 / 2.54;\r\n        break;\r\n      case 'in':\r\n        k = 72;\r\n        break;\r\n      case 'px':\r\n        k = 96 / 72;\r\n        break;\r\n      case 'pc':\r\n        k = 12;\r\n        break;\r\n      case 'em':\r\n        k = 12;\r\n        break;\r\n      case 'ex':\r\n        k = 6;\r\n        break;\r\n      default:\r\n        throw new Error('Invalid unit: ' + unit);\r\n    }\r\n\r\n    return n * k;\r\n  }\r\n}\r\n"]}