@plusscommunities/pluss-core-app 1.7.0 → 1.7.1

package/src/js/images/findLandmarkRange.js

@@ -0,0 +1,105 @@
+import _ from 'lodash';
+import moment from 'moment';
+import { stringActions } from '../../apis';
+import detectFaces from './detectFaces';
+import getScaledOffset from './getScaledOffset';
+
+const findLandmarkRange = async (url, options) => {
+  let cachedValues;
+  if (options && options.cachedValues) {
+    cachedValues = options.cachedValues;
+  }
+  try {
+    const response = await stringActions.getString('plussSpace', `imagefaces_${encodeURIComponent(url)}`);
+    cachedValues = response.data;
+  } catch (e) {
+    console.log('errored from cache');
+  }
+  if (
+    !cachedValues ||
+    !cachedValues.faces ||
+    !cachedValues.image ||
+    (_.isEmpty(cachedValues.faces) &&
+      moment()
+        .add(-1, 'w')
+        .valueOf() > moment(cachedValues.timestamp).valueOf())
+  ) {
+    cachedValues = await detectFaces(url);
+  }
+  const { faces, image } = cachedValues;
+
+  let landmarkStartX = null;
+  let landmarkStartY = null;
+  let landmarkEndX = null;
+  let landmarkEndY = null;
+
+  if (_.isEmpty(faces)) {
+    landmarkStartX = image.width / 2;
+    landmarkStartY = image.height / 2;
+    landmarkEndX = image.width / 2;
+    landmarkEndY = image.height / 2;
+  } else {
+    faces.forEach(face => {
+      const { bounds } = face;
+
+      if (!landmarkStartX || bounds.origin.x < landmarkStartX) {
+        landmarkStartX = bounds.origin.x;
+      }
+
+      if (!landmarkStartY || bounds.origin.y < landmarkStartY) {
+        landmarkStartY = bounds.origin.y;
+      }
+
+      const faceEndX = bounds.origin.x + bounds.size.width;
+      if (!landmarkEndX || faceEndX > landmarkEndX) {
+        landmarkEndX = faceEndX;
+      }
+
+      const faceEndY = bounds.origin.y + bounds.size.height;
+      if (!landmarkEndY || faceEndX > landmarkEndY) {
+        landmarkEndY = faceEndY;
+      }
+    });
+  }
+
+  let targetWidth = image.width;
+  let targetHeight = image.height;
+
+  if (options && options.targetWidth && options.targetHeight) {
+    const { scaleFactor } = getScaledOffset(image.width, image.height, options.targetWidth, options.targetHeight);
+    landmarkStartX *= scaleFactor;
+    landmarkStartY *= scaleFactor;
+    landmarkEndX *= scaleFactor;
+    landmarkEndY *= scaleFactor;
+    targetWidth = options.targetWidth;
+    targetHeight = options.targetHeight;
+  }
+
+  if (landmarkStartX < 0) {
+    landmarkStartX = 0;
+  }
+  if (landmarkStartY < 0) {
+    landmarkStartY = 0;
+  }
+  if (landmarkEndX > targetWidth) {
+    landmarkEndX = targetWidth;
+  }
+  if (landmarkEndY > targetHeight) {
+    landmarkEndY = targetHeight;
+  }
+
+  return {
+    start: {
+      x: landmarkStartX,
+      y: landmarkStartY,
+    },
+    end: {
+      x: landmarkEndX,
+      y: landmarkEndY,
+    },
+    height: image.height,
+    width: image.width,
+  };
+};
+
+export default findLandmarkRange;

package/src/js/images/getScaledOffset.js

@@ -0,0 +1,83 @@
+const getScaledOffset = (sourceWidth, sourceHeight, targetWidth, targetHeight) => {
+  const sourceRatio = sourceWidth / sourceHeight;
+  const targetRatio = targetWidth / targetHeight;
+
+  // same ratio. no adjustment needed.
+  if (sourceRatio === targetRatio) {
+    return {
+      width: targetWidth,
+      height: targetHeight,
+      scaleFactor: targetWidth / sourceWidth,
+      offset: {
+        x: 0,
+        y: 0,
+      },
+      bounds: {
+        start: {
+          x: 0,
+          y: 0,
+        },
+        end: {
+          x: targetWidth,
+          y: targetHeight,
+        },
+      },
+    };
+  }
+
+  // source is higher than target. height scaling and y offset required.
+  if (sourceRatio < targetRatio) {
+    const scaleFactor = targetWidth / sourceWidth;
+    const adjustedHeight = sourceHeight * scaleFactor;
+    const yOffset = (adjustedHeight - targetHeight) / 2;
+
+    return {
+      width: targetWidth,
+      height: adjustedHeight,
+      scaleFactor,
+      offset: {
+        x: 0,
+        y: -yOffset,
+      },
+      bounds: {
+        start: {
+          x: 0,
+          y: yOffset,
+        },
+        end: {
+          x: targetWidth,
+          y: yOffset + adjustedHeight,
+        },
+      },
+    };
+  }
+
+  // source is wider than target. width scaling and x offset required.
+  if (sourceRatio > targetRatio) {
+    const scaleFactor = targetHeight / sourceHeight;
+    const adjustedWidth = sourceWidth * scaleFactor;
+    const xOffset = (adjustedWidth - targetWidth) / 2;
+
+    return {
+      width: adjustedWidth,
+      height: targetHeight,
+      scaleFactor,
+      offset: {
+        x: -xOffset,
+        y: 0,
+      },
+      bounds: {
+        start: {
+          x: xOffset,
+          y: 0,
+        },
+        end: {
+          x: xOffset + adjustedWidth,
+          y: targetHeight,
+        },
+      },
+    };
+  }
+};
+
+export default getScaledOffset;