medsurf-draw/dist/lib/generators/copies/CloneLayerGenerator.js

Draw annotations on jpg/zoomify images, based on PIXI.js

var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import * as PIXI from 'pixi.js-legacy';
import * as MedsurfDraw from '../../public-api';
import * as Models from '@ascii-dev-user/medsurf-lib/models';
import { ImageObjectType } from '@ascii-dev-user/medsurf-lib/models';
import { v4 as uuidv4 } from 'uuid';
import { BaseGenerator, BaseGeneratorModel } from '../../bases/generators/BaseGenerator';
import { debounce } from 'debounce';
var CopyLayerGroupMapping = (function () {
    function CopyLayerGroupMapping() {
    }
    return CopyLayerGroupMapping;
}());
export { CopyLayerGroupMapping };
var CloneLayerGeneratorModel = (function (_super) {
    __extends(CloneLayerGeneratorModel, _super);
    function CloneLayerGeneratorModel() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return CloneLayerGeneratorModel;
}(BaseGeneratorModel));
export { CloneLayerGeneratorModel };
var CloneLayerGenerator = (function (_super) {
    __extends(CloneLayerGenerator, _super);
    function CloneLayerGenerator(model) {
        var _this = _super.call(this, model) || this;
        _this._generators = [];
        _this._debounceEndGeneratorMethod = debounce(_this.endClone.bind(_this), 20).bind(_this);
        _this.target.modeInteraction.setModeItem("cloning");
        _this._cloneLayerGroup = _this.cloneLayerGroup(_this.data.cloneLayerGroup, _this.data.relativePoint);
        var globalPoint = _this.target.renderer.plugins.interaction.mouse.global;
        var hitTest = _this.target.renderer.plugins.interaction.hitTest(globalPoint, _this.target.parent);
        if (!hitTest) {
            _this.target.parent.once("pointerover", _this.start, _this);
        }
        else {
            var event_1 = new PIXI.InteractionEvent();
            event_1.data = new PIXI.InteractionData();
            event_1.data.global = globalPoint;
            _this.emit("debounceStart", event_1);
        }
        return _this;
    }
    CloneLayerGenerator.prototype.start = function (event) {
        this.target.parent.on("rightup", this.abortClone, this);
        for (var _i = 0, _a = this._generators; _i < _a.length; _i++) {
            var generator = _a[_i];
            generator.emit("debounceStart", event);
            generator.once('endGenerator', this._debounceEndGeneratorMethod, this);
        }
        _super.prototype.start.call(this, event);
    };
    CloneLayerGenerator.prototype.end = function () {
        this.target.parent.off("rightup", this.abortClone, this);
        for (var _i = 0, _a = this._generators; _i < _a.length; _i++) {
            var generator = _a[_i];
            generator.emit("debounceEnd");
        }
        _super.prototype.end.call(this);
    };
    CloneLayerGenerator.prototype.destroy = function (options) {
        this.end();
    };
    CloneLayerGenerator.prototype.endGenerator = function () {
        this.cloneRelations();
        _super.prototype.endGenerator.call(this);
        this.target.sortChildren();
        this.target.modeInteraction.setMode(this.target.modeInteraction.defaultMode);
    };
    CloneLayerGenerator.prototype.abortGenerator = function () {
        _super.prototype.abortGenerator.call(this);
        var imageObjects = this.target.getImageObjects();
        imageObjects.filter(function (imageObject) { return imageObject.modeInteraction.lastMode.startsWith('clone')
            && imageObject.modeInteraction.lastMode.endsWith('_new'); })
            .sort(function (a, b) {
            var aModel = a.model;
            var bModel = b.model;
            if (aModel.type === Models.ImageObjectType.LINE) {
                if (bModel.type === Models.ImageObjectType.LINE) {
                    return 0;
                }
                else {
                    return -1;
                }
            }
            else {
                if (bModel.type === Models.ImageObjectType.LINE) {
                    return 1;
                }
            }
            return 0;
        }).forEach(function (imageObject) {
            imageObject.modeInteraction.setMode("delete_clone");
        });
        this.target.sortChildren();
        this.target.modeInteraction.setMode(this.target.modeInteraction.defaultMode);
    };
    CloneLayerGenerator.prototype.cloneLayerGroup = function (model, relativePoint) {
        if (relativePoint === void 0) { relativePoint = undefined; }
        var layer;
        var layerMapping = this.data.layerGroupMappings.find(function (mapping) { return mapping.old.id === model.id; });
        if (layerMapping) {
            layer = layerMapping.new;
        }
        else {
            layer = this.createLayerGroupInstance(model, relativePoint);
        }
        return layer;
    };
    CloneLayerGenerator.prototype.cloneLayerImageObject = function (layerImageObject, layerModel, relativePoint) {
        var _a;
        if (relativePoint === void 0) { relativePoint = undefined; }
        var imageObject;
        var imageObjectModel = this.data.imageObjects.find(function (imageObject) { return imageObject.id === layerImageObject.imageObject; });
        if (imageObjectModel) {
            var generator = new MedsurfDraw.CloneItemGenerator({
                imageObjects: this.data.imageObjects,
                layerGroup: layerModel,
                image: this.data.image,
                target: this.target,
                element: imageObjectModel,
                imageObjectMappings: this.data.imageObjectMappings,
                relativePoint: relativePoint,
            });
            imageObject = generator.cloneElement;
            (_a = this.data.imageObjectMappings).push.apply(_a, generator.data.imageObjectMappings);
            relativePoint = generator.data.relativePoint;
            this._generators.push(generator);
        }
        else {
            throw 'Image object not created';
        }
        var layerImageObjectModel = this.createLayerImageObjectModel(layerImageObject, layerModel, imageObject.name);
        if (!relativePoint) {
            relativePoint = { x: 0, y: 0 };
        }
        return { element: layerImageObjectModel, relativePoint: relativePoint };
    };
    CloneLayerGenerator.prototype.cloneRelations = function () {
        var _this = this;
        this.data.imageObjectMappings.forEach(function (imageObjectMapping) {
            var oldItem = imageObjectMapping.old;
            var newItem = imageObjectMapping.new;
            switch (oldItem.type) {
                case ImageObjectType.POSITIONPOINT:
                    (oldItem.selftestItems || []).forEach(function (item) {
                        var reference = _this.data.imageObjectMappings.find(function (mapping) { return mapping.old.id === item; });
                        if (reference && reference.new) {
                            newItem.selftestItems.push(reference.new.id);
                        }
                    });
                    break;
                case ImageObjectType.FILLCOLLECTION:
                    (oldItem.interactiveItems || []).forEach(function (item) {
                        var reference = _this.data.imageObjectMappings.find(function (mapping) { return mapping.old.id === item; });
                        if (reference && reference.new) {
                            newItem.interactiveItems.push(reference.new.id);
                        }
                    });
                    break;
            }
        });
    };
    CloneLayerGenerator.prototype.createLayerGroupInstance = function (model, relativePoint) {
        if (relativePoint === void 0) { relativePoint = undefined; }
        var layerModel = this.createLayerGroupModel(model);
        var tmpLayerGroupContents = [];
        Object.assign(tmpLayerGroupContents, model.groupContents || []);
        var layerGroupContents = [];
        for (var _i = 0, tmpLayerGroupContents_1 = tmpLayerGroupContents; _i < tmpLayerGroupContents_1.length; _i++) {
            var layerGroupContent = tmpLayerGroupContents_1[_i];
            var layerGroupContentModel = this.createLayerGroupContentModel(layerGroupContent);
            layerGroupContents.push(layerGroupContentModel);
        }
        layerModel.groupContents = layerGroupContents;
        var tmpLayerImageObjects = [];
        Object.assign(tmpLayerImageObjects, model.layerImageObjects || []);
        for (var _a = 0, tmpLayerImageObjects_1 = tmpLayerImageObjects; _a < tmpLayerImageObjects_1.length; _a++) {
            var layerImageObject = tmpLayerImageObjects_1[_a];
            var data = this.cloneLayerImageObject(layerImageObject, layerModel, relativePoint);
            layerImageObject = data.element;
            relativePoint = data.relativePoint;
        }
        this.data.layerGroupMappings.push({
            new: layerModel,
            old: model
        });
        this.target.layerGroups.push(layerModel);
        return layerModel;
    };
    CloneLayerGenerator.prototype.createLayerGroupModel = function (model) {
        return {
            dirty: true,
            id: uuidv4(),
            image: model.image,
            name: model.name,
            order: model.order,
            groupContents: [],
            layerImageObjects: [],
        };
    };
    CloneLayerGenerator.prototype.createLayerGroupContentModel = function (model) {
        return {
            dirty: true,
            id: uuidv4(),
            order: model.order,
            content: model.content,
        };
    };
    CloneLayerGenerator.prototype.createLayerImageObjectModel = function (model, layerGroup, imageObject) {
        return {
            dirty: true,
            id: uuidv4(),
            layerGroup: layerGroup,
            order: model.order,
            imageObject: imageObject,
        };
    };
    CloneLayerGenerator.prototype.endClone = function (event) {
        event.stopPropagation();
        this.emit("endGenerator");
        this.end();
    };
    CloneLayerGenerator.prototype.abortClone = function (event) {
        event.stopPropagation();
        this.emit("abortGenerator");
        this.destroy();
    };
    return CloneLayerGenerator;
}(BaseGenerator));
export { CloneLayerGenerator };
//# sourceMappingURL=CloneLayerGenerator.js.map