matting-editor/lib/utils/matting-image.js

matting-editor

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _axios = require('axios');

var _axios2 = _interopRequireDefault(_axios);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _md = require('crypto-js/md5');

var _md2 = _interopRequireDefault(_md);

var _drawImageWithMask = require('./draw-image-with-mask');

var _drawImageWithMask2 = _interopRequireDefault(_drawImageWithMask);

var _dataurlToBlob = require('./dataurl-to-blob');

var _dataurlToBlob2 = _interopRequireDefault(_dataurlToBlob);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var maskCaches = {};
var mattingCaches = {};

var requestMatting = function requestMatting() {
    var matting = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var mattingData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
        onPreview = _ref.onPreview,
        mattingImage = _ref.mattingImage,
        uploadImage = _ref.uploadImage;

    return _bluebird2.default.try(function () {
        return mattingImage(matting);
    }).then(function (data) {
        var ret = _lodash2.default.cloneDeep(data);
        var maskHash = (0, _md2.default)(data.mask_url);

        data.mask_hash = maskHash;
        data.ret = ret;

        if (maskCaches[maskHash]) {
            return data;
        }

        return _axios2.default.get(data.mask_url, {
            responseType: 'arraybuffer'
        }).then(function (res) {
            data.mask_buffer = res.data;

            return data;
        });
    }).then(function (data) {
        var maskHash = data.mask_hash;
        var ret = {
            resultImage: maskCaches[maskHash] || '',
            edge_paths: data.edge_paths
        };

        if (ret.resultImage) {
            return ret;
        }

        return (0, _drawImageWithMask2.default)(mattingData.sourceImage, data.mask_buffer).then(function (canvas) {
            var dataURL = canvas.toDataURL();
            var blob = (0, _dataurlToBlob2.default)(dataURL);

            ret.resultImage = dataURL;
            onPreview(ret, data.ret);

            return uploadImage(blob, matting);
        }).then(function (res) {
            ret.resultImage = res.url;

            return ret;
        });
    });
};

exports.default = function () {
    var matting = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var mattingData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
        _ref2$onPreview = _ref2.onPreview,
        onPreview = _ref2$onPreview === undefined ? function () {} : _ref2$onPreview,
        _ref2$mattingImage = _ref2.mattingImage,
        mattingImage = _ref2$mattingImage === undefined ? function () {} : _ref2$mattingImage,
        _ref2$uploadImage = _ref2.uploadImage,
        uploadImage = _ref2$uploadImage === undefined ? function () {} : _ref2$uploadImage;

    var dataHash = (0, _md2.default)(JSON.stringify({
        lines: mattingData.lines,
        featheringRadius: mattingData.featheringRadius
    }));

    var promise = mattingCaches[dataHash];
    if (!promise) {
        promise = mattingCaches[dataHash] = requestMatting(matting, mattingData, {
            onPreview: onPreview,
            mattingImage: mattingImage,
            uploadImage: uploadImage
        }).catch(function (err) {
            delete mattingCaches[dataHash];

            throw err;
        });
    }

    return promise.tap(function () {
        mattingCaches[dataHash] = promise;
    });
};