apexify.js 4.5.54 → 4.5.56

package/lib/canvas/utils/{general functions.ts → General/general functions.ts }

@@ -1,7 +1,7 @@
 import path from 'path'
 import sharp from 'sharp';
-import { cropOptions } from './types';
-import { createCanvas, loadImage } from '@napi-rs/canvas';
+import { cropOptions, ResizeOptions } from '../types';
+import { createCanvas, loadImage, SKRSContext2D } from '@napi-rs/canvas';
 import fs from "fs";
 import axios from "axios";
 
@@ -28,41 +28,53 @@ export async function loadImages(imagePath: string) {
   }
 }
 
-export async function resizingImg(resizeOptions: any): Promise<Buffer> {
+
+/**
+ * Resizes an image using Sharp with additional options for quality, kernel, and withoutEnlargement.
+ * 
+ * @param resizeOptions - The options for resizing.
+ * @returns A Promise that resolves with the resized image as a Buffer.
+ */
+export async function resizingImg(resizeOptions: ResizeOptions): Promise<Buffer> {
   try {
-      if (!resizeOptions.imagePath) {
-          throw new Error("Image path is required for resizing.");
-      }
+    if (!resizeOptions.imagePath) {
+      throw new Error("Image path is required for resizing.");
+    }
 
-      let absoluteImagePath;
-      
-      if (resizeOptions.imagePath.startsWith("http")) {
-          absoluteImagePath = resizeOptions.imagePath;
-      } else {
-          absoluteImagePath = path.join(process.cwd(), resizeOptions.imagePath);
-      }
+    let absoluteImagePath: string;
+    if (resizeOptions.imagePath.startsWith("http")) {
+      absoluteImagePath = resizeOptions.imagePath;
+    } else {
+      absoluteImagePath = path.join(process.cwd(), resizeOptions.imagePath);
+    }
+
+    const image = sharp(absoluteImagePath);
 
-      let image = sharp(absoluteImagePath);
+    const resizeOptionsForSharp: sharp.ResizeOptions = {
+      width: resizeOptions.size?.width || 500,
+      height: resizeOptions.size?.height || 500,
+      fit: resizeOptions.maintainAspectRatio ? sharp.fit.inside : sharp.fit.fill,
+      kernel: sharp.kernel.lanczos3,
+      withoutEnlargement: true,
+    };
 
-      const resizeOptionsForSharp = {
-          width: resizeOptions.size?.width || 500,
-          height: resizeOptions.size?.height || 500,
-          fit: resizeOptions.maintainAspectRatio ? sharp.fit.inside : sharp.fit.fill
-        };
+    const quality = resizeOptions.quality ?? 90;
 
-      const resizedBuffer = await image
-          .resize(resizeOptionsForSharp)
-          .png()
-          .toBuffer();
+    const resizedBuffer: Buffer =  await image
+      .resize(resizeOptionsForSharp)
+      .png({ quality })
+      .toBuffer();
+  
 
-      return resizedBuffer;
+    return resizedBuffer;
 
   } catch (error) {
-      console.error("Error resizing image:", error);
-      throw new Error("Failed to resize image");
+    console.error("Error resizing image:", error);
+    throw new Error("Failed to resize image");
   }
 }
 
+
 export async function converter(imagePath: string, newExtension: string) {
   try {
       const validExtensions: (keyof sharp.FormatEnum)[] = ['jpeg', 'png', 'webp', 'tiff', 'gif', 'avif', 'heif', 'raw', 'pdf', 'svg'];
@@ -249,114 +261,124 @@ export async function imgEffects(imagePath: string, filters: any[]) {
 }
 
 
-export async function cropInner(options: cropOptions): Promise<any> {
-    try {
-      
-      let image;
-
-      if (options.imageSource.startsWith('http')) {
-        image = await loadImage(options.imageSource);
-      } else {
-        image = await loadImage(path.join(process.cwd(), options.imageSource));
-      }
-      
-        const width = Math.abs(options.coordinates[0].from.x - options.coordinates[1].to.x);
-        const height = Math.abs(options.coordinates[0].from.y - options.coordinates[2].to.y);
-
-        const canvas = createCanvas(width, height);
-        const ctx = canvas.getContext('2d');
-
-        if (options.radius === 'circular') {
-            const radius = Math.min(width, height) / 2;
-            ctx.arc(width / 2, height / 2, radius, 0, Math.PI * 2);
-            ctx.closePath();
-            ctx.clip();
-        } else if (typeof options.radius === 'number' && options.radius >= 0) {
-            ctx.beginPath();
-            ctx.moveTo(options.radius, 0);
-            ctx.lineTo(width - options.radius, 0);
-            ctx.quadraticCurveTo(width, 0, width, options.radius);
-            ctx.lineTo(width, height - options.radius);
-            ctx.quadraticCurveTo(width, height, width - options.radius, height);
-            ctx.lineTo(options.radius, height);
-            ctx.quadraticCurveTo(0, height, 0, height - options.radius);
-            ctx.lineTo(0, options.radius);
-            ctx.quadraticCurveTo(0, 0, options.radius, 0);
-            ctx.closePath();
-            ctx.clip();
-            // @ts-ignore
-        } else if (options.radius !== null && options.radius !== 'circular' && (typeof options.radius !== 'number' || options.radius < 0)) {
-            throw new Error('The "radius" option can only be "circular" or a non-negative number.');
-        }
-        
-
-        ctx.drawImage(image, options.coordinates[0].from.x, options.coordinates[0].from.y, width, height, 0, 0, width, height);
+/**
+ * Crops the inner portion of the image based on the bounding box of the provided coordinates.
+ * Optionally applies a clipping mask with a specified radius.
+ */
+export async function cropInner(options: cropOptions): Promise<Buffer> {
+  try {
+    // Load the image (from HTTP or local path)
+    let image;
+    if (options.imageSource.startsWith("http")) {
+      image = await loadImage(options.imageSource);
+    } else {
+      image = await loadImage(path.join(process.cwd(), options.imageSource));
+    }
 
+    // Compute the bounding box from all coordinate points.
+    const xs: number[] = [];
+    const ys: number[] = [];
+    for (const coord of options.coordinates) {
+      xs.push(coord.from.x, coord.to.x);
+      ys.push(coord.from.y, coord.to.y);
+    }
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    const cropWidth = maxX - minX;
+    const cropHeight = maxY - minY;
+
+    // Create a canvas with the crop dimensions.
+    const canvas = createCanvas(cropWidth, cropHeight);
+    const ctx = canvas.getContext('2d') as SKRSContext2D;
+    if (!ctx) throw new Error("Unable to get 2D context");
+
+    // Optionally, apply a clipping mask if a radius is provided.
+    if (options.radius !== undefined && options.radius !== null) {
+      if (options.radius === "circular") {
+        const radius = Math.min(cropWidth, cropHeight) / 2;
         ctx.beginPath();
-        for (let i = 0; i < options.coordinates.length; i++) {
-            const coordinate = options.coordinates[i];
-            const nextCoordinate = options.coordinates[(i + 1) % options.coordinates.length];
-            const tension = coordinate.tension || 0;
-            const cp1x = coordinate.from.x + (nextCoordinate.from.x - coordinate.from.x) * tension;
-            const cp1y = coordinate.from.y + (nextCoordinate.from.y - coordinate.from.y) * tension;
-            const cp2x = coordinate.to.x - (nextCoordinate.to.x - coordinate.to.x) * tension;
-            const cp2y = coordinate.to.y - (nextCoordinate.to.y - coordinate.to.y) * tension;
-            ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, coordinate.to.x, coordinate.to.y);
-        }
+        ctx.arc(cropWidth / 2, cropHeight / 2, radius, 0, Math.PI * 2);
         ctx.closePath();
-
-        const buffer = canvas.toBuffer('image/png');
-
-        return buffer;
-
-    } catch (error) {
-        console.error('An error occurred:', error);
-        throw error;
-    }
-}
-
-export async function cropOuter(options: cropOptions): Promise<any> {
-    try {
-
-      let image;
-
-      if (options.imageSource.startsWith('http')) {
-        image = await loadImage(options.imageSource);
+        ctx.clip();
+      } else if (typeof options.radius === 'number' && options.radius >= 0) {
+        ctx.beginPath();
+        ctx.moveTo(options.radius, 0);
+        ctx.lineTo(cropWidth - options.radius, 0);
+        ctx.quadraticCurveTo(cropWidth, 0, cropWidth, options.radius);
+        ctx.lineTo(cropWidth, cropHeight - options.radius);
+        ctx.quadraticCurveTo(cropWidth, cropHeight, cropWidth - options.radius, cropHeight);
+        ctx.lineTo(options.radius, cropHeight);
+        ctx.quadraticCurveTo(0, cropHeight, 0, cropHeight - options.radius);
+        ctx.lineTo(0, options.radius);
+        ctx.quadraticCurveTo(0, 0, options.radius, 0);
+        ctx.closePath();
+        ctx.clip();
       } else {
-        image = await loadImage(path.join(process.cwd(), options.imageSource));
+        throw new Error('The "radius" option can only be "circular" or a non-negative number.');
       }
+    }
 
-        const canvas = createCanvas(image.width, image.height);
-        const ctx = canvas.getContext('2d');
+    // Draw the region from the original image corresponding to the bounding box.
+    // drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight)
+    ctx.drawImage(image, minX, minY, cropWidth, cropHeight, 0, 0, cropWidth, cropHeight);
 
-        ctx.drawImage(image, 0, 0);
+    return canvas.toBuffer('image/png');
+  } catch (error) {
+    console.error('An error occurred in cropInner:', error);
+    throw error;
+  }
+}
 
-        ctx.beginPath();
-        ctx.moveTo(options.coordinates[0].from.x, options.coordinates[0].from.y);
-        for (let i = 0; i < options.coordinates.length; i++) {
-            const coordinate = options.coordinates[i];
-            const nextCoordinate = options.coordinates[(i + 1) % options.coordinates.length];
-            const tension = coordinate.tension || 0;
-            const cp1x = coordinate.from.x + (nextCoordinate.from.x - coordinate.from.x) * tension;
-            const cp1y = coordinate.from.y + (nextCoordinate.from.y - coordinate.from.y) * tension;
-            const cp2x = coordinate.to.x - (nextCoordinate.to.x - coordinate.to.x) * tension;
-            const cp2y = coordinate.to.y - (nextCoordinate.to.y - coordinate.to.y) * tension;
-            ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, coordinate.to.x, coordinate.to.y);
-        }
-        ctx.closePath();
+/**
+ * Crops the outer portion of the image by removing the area defined by the provided polygon.
+ * The polygon is defined by the coordinates (with optional bezier smoothing using tension).
+ */
+export async function cropOuter(options: cropOptions): Promise<Buffer> {
+  try {
+    let image;
+    if (options.imageSource.startsWith("http")) {
+      image = await loadImage(options.imageSource);
+    } else {
+      image = await loadImage(path.join(process.cwd(), options.imageSource));
+    }
 
-        ctx.clip();
+    // Create a canvas matching the full image dimensions.
+    const canvas = createCanvas(image.width, image.height);
+    const ctx = canvas.getContext('2d') as SKRSContext2D;
+    if (!ctx) throw new Error("Unable to get 2D context");
 
-        ctx.clearRect(0, 0, canvas.width, canvas.height);
+    // Draw the full image.
+    ctx.drawImage(image, 0, 0);
 
-        const buffer = canvas.toBuffer('image/png');
+    // Build the polygon path from the provided coordinates.
+    ctx.beginPath();
+    // Start at the first coordinate's "from" point.
+    ctx.moveTo(options.coordinates[0].from.x, options.coordinates[0].from.y);
+    for (let i = 0; i < options.coordinates.length; i++) {
+      const coord = options.coordinates[i];
+      const nextCoord = options.coordinates[(i + 1) % options.coordinates.length];
+      const tension = coord.tension || 0;
+      const cp1x = coord.from.x + (nextCoord.from.x - coord.from.x) * tension;
+      const cp1y = coord.from.y + (nextCoord.from.y - coord.from.y) * tension;
+      const cp2x = coord.to.x - (nextCoord.to.x - coord.to.x) * tension;
+      const cp2y = coord.to.y - (nextCoord.to.y - coord.to.y) * tension;
+      ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, coord.to.x, coord.to.y);
+    }
+    ctx.closePath();
 
-        return buffer;
+    // Set the clipping region to the polygon.
+    ctx.clip();
 
-    } catch (error) {
-        console.error('An error occurred:', error);
-        throw error;
-    }
+    // Clear the inner region defined by the clipping path.
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    return canvas.toBuffer('image/png');
+  } catch (error) {
+    console.error('An error occurred in cropOuter:', error);
+    throw error;
+  }
 }