apexify.js 4.5.50 → 4.5.51

package/lib/canvas/ApexPainter.ts

@@ -297,7 +297,7 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
       }
   } catch (e: any) {
       console.error(e.message);
-      throw e; // Re-throw the error after logging
+      throw e;
   }
 }
 
@@ -345,15 +345,12 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
     baseImageBuffer: Buffer
   ): Promise<Buffer> {
     try {
-      // Load the base image
       const baseImage = await loadImage(baseImageBuffer);
       const canvas = createCanvas(baseImage.width, baseImage.height);
       const ctx = canvas.getContext('2d');
   
-      // Draw the base image
       ctx.drawImage(baseImage, 0, 0);
   
-      // Process each layer
       for (const layer of layers) {
         const layerImage = await loadImage(layer.image);
         ctx.globalAlpha = layer.opacity !== undefined ? layer.opacity : 1.0; 
@@ -524,8 +521,8 @@ async extractFrames(videoSource: string | Buffer, options: ExtractFramesOptions)
               console.error('Error extracting frames:', err.message);
               reject(err);
           })
-          .outputOptions([`-vf fps=1/${options.interval / 1000}`, `-q:v 2`]) // Set frame rate
-          .saveToFile(path.join(frameDir, outputFileTemplate)); // Save frames with a sequence number
+          .outputOptions([`-vf fps=1/${options.interval / 1000}`, `-q:v 2`])
+          .saveToFile(path.join(frameDir, outputFileTemplate)); 
 
       ffmpeg.ffprobe(videoPath, (err, metadata) => {
           if (err) {
@@ -562,13 +559,12 @@ async extractFrames(videoSource: string | Buffer, options: ExtractFramesOptions)
  * @returns {Promise<Buffer>} - The adjusted image buffer.
  */
 async setPatternBackground(buffer:Buffer, options: PatternOptions) {
-    // Load the buffered image onto a canvas
+
     const img = await loadImage(buffer);
     const canvas = createCanvas(img.width, img.height);
     const ctx: any = canvas.getContext('2d');
     ctx.drawImage(img, 0, 0);
 
-    // Set up the area to cover (default to full image if not specified)
     const x = options.x || 0;
     const y = options.y || 0;
     const width = options.width || img.width;
@@ -713,20 +709,16 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
   
     ctx.fillStyle = color;
     
-    // Save the context to apply transformations and restore later
     ctx.save();
   
-    // Translate and rotate the canvas
-    ctx.translate(x + width / 2, y + height / 2); // Move to the center of the area
-    ctx.rotate((angle * Math.PI) / 180); // Rotate by the specified angle
-    ctx.translate(-width / 2, -height / 2); // Translate back to top-left
+    ctx.translate(x + width / 2, y + height / 2);
+    ctx.rotate((angle * Math.PI) / 180);
+    ctx.translate(-width / 2, -height / 2);
   
-    // Draw the stripes pattern with the current transformations
     for (let posX = 0; posX < width; posX += stripeWidth + spacing) {
       ctx.fillRect(posX, 0, stripeWidth, height);
     }
   
-    // Restore the original context to prevent transformations affecting other drawings
     ctx.restore();
   }
     /**

package/lib/canvas/utils/general functions.ts

@@ -2,7 +2,8 @@ import path from 'path'
 import sharp from 'sharp';
 import { cropOptions } from './types';
 import { createCanvas, loadImage } from '@napi-rs/canvas';
-import Jimp from 'jimp';
+import fs from "fs";
+import axios from "axios";
 
 export async function loadImages(imagePath: string) {
   try {
@@ -184,95 +185,67 @@ function createGradientImage(width: number, height: number, options: any, opacit
   return gradientCanvas.toBuffer('image/png');
 }
 
-export async function imgEffects(imagePath: string,  filters: any[]) {
-    try {
-        let jimpImage;
-  
-        if (imagePath.startsWith("http")) {
-          const pngBuffer = await converter(imagePath, "png");
-          jimpImage = await Jimp.read(pngBuffer);
-        } else {
-          const imagePathResolved = path.join(process.cwd(), imagePath)
-          jimpImage = await Jimp.read(imagePathResolved);
-        }
-  
-        for (const filter of filters) {
-          switch (filter.type) {
-            case "flip":
-              jimpImage.flip(filter.horizontal, filter.vertical);
-              break;
-            case "mirror":
-              jimpImage.mirror(filter.horizontal, filter.vertical);
-              break;
-            case "rotate":
-              jimpImage.rotate(filter.deg, filter.mode);
-              break;
-            case "brightness":
-              jimpImage.brightness(filter.value);
-              break;
-            case "contrast":
-              jimpImage.contrast(filter.value);
-              break;
-            case "dither565":
-              jimpImage.dither565();
-              break;
-            case "greyscale":
-              jimpImage.greyscale();
-              break;
-            case "invert":
-              jimpImage.invert();
-              break;
-            case "normalize":
-              jimpImage.normalize();
-              break;
-            case "autocrop":
-              jimpImage.autocrop(filter.tolerance || 0);
-              break;
-            case "crop":
-              jimpImage.crop(filter.x, filter.y, filter.w, filter.h);
-              break;
-            case "fade":
-              jimpImage.fade(filter.factor);
-              break;
-            case "opacity":
-              jimpImage.opacity(filter.factor);
-              break;
-            case "opaque":
-              jimpImage.opaque();
-              break;
-            case "gaussian":
-              jimpImage.gaussian(filter.radius);
-              break;
-            case "blur":
-              jimpImage.blur(filter.radius);
-              break;
-            case "posterize":
-              jimpImage.posterize(filter.levels);
-              break;
-            case "sepia":
-              jimpImage.sepia();
-              break;
-            case "pixelate":
-              jimpImage.pixelate(
-                filter.size,
-                filter.x,
-                filter.y,
-                filter.w,
-                filter.h,
-              );
-              break;
-            default:
-              console.error(`Unsupported filter type: ${filter.type}`);
-          }
-        }
-  
-        const outputMimeType = Jimp.MIME_PNG;
-  
-        return await jimpImage.getBufferAsync(outputMimeType);
-      } catch (error: any) {
-        console.error("Error processing image:", error.message);
-        throw new Error("Failed to process image");
+
+
+export async function imgEffects(imagePath: string, filters: any[]) {
+  try {
+    let image;
+
+    if (imagePath.startsWith("http")) {
+      const response = await axios.get(imagePath, { responseType: "arraybuffer" });
+      image = await loadImage(response.data);
+    } else {
+      const imagePathResolved = path.resolve(process.cwd(), imagePath);
+      image = await loadImage(fs.readFileSync(imagePathResolved));
     }
+
+    const canvas = createCanvas(image.width, image.height);
+    const ctx = canvas.getContext("2d");
+
+    ctx.drawImage(image, 0, 0);
+
+    for (const filter of filters) {
+      switch (filter.type) {
+        case "flip":
+          flipCanvas(ctx, image.width, image.height, filter.horizontal, filter.vertical);
+          break;
+        case "rotate":
+          rotateCanvas(ctx, canvas, filter.deg);
+          break;
+        case "brightness":
+          adjustBrightness(ctx, filter.value);
+          break;
+        case "contrast":
+          adjustContrast(ctx, filter.value);
+          break;
+        case "invert":
+          invertColors(ctx);
+          break;
+        case "greyscale":
+          grayscale(ctx);
+          break;
+        case "sepia":
+          applySepia(ctx);
+          break;
+        case "blur":
+          applyBlur(ctx, filter.radius);
+          break;
+        case "posterize":
+          posterize(ctx, filter.levels);
+          break;
+        case "pixelate":
+          pixelate(ctx, filter.size, filter.x, filter.y, filter.w, filter.h);
+          break;
+        default:
+          console.error(`Unsupported filter type: ${filter.type}`);
+      }
+    }
+
+    return canvas.toBuffer("image/png");
+  } catch (error: any) {
+    console.error("Error processing image:", error.message);
+    throw new Error("Failed to process image");
+  }
 }
 
 
@@ -509,3 +482,187 @@ export async function bgRemoval(imgURL: string, API_KEY: string): Promise<Buffer
       return undefined;
   }
 }
+
+
+function flipCanvas(ctx: any, width: number, height: number, horizontal = false, vertical = false) {
+  const imageData = ctx.getImageData(0, 0, width, height);
+  const pixels = imageData.data;
+
+  const newData = new Uint8ClampedArray(pixels.length);
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const srcIndex = (y * width + x) * 4;
+      let destX = horizontal ? width - x - 1 : x;
+      let destY = vertical ? height - y - 1 : y;
+      const destIndex = (destY * width + destX) * 4;
+
+      newData[destIndex] = pixels[srcIndex];
+      newData[destIndex + 1] = pixels[srcIndex + 1];
+      newData[destIndex + 2] = pixels[srcIndex + 2];
+      newData[destIndex + 3] = pixels[srcIndex + 3];
+    }
+  }
+
+  ctx.putImageData(new ImageData(newData, width, height), 0, 0);
+}
+
+function rotateCanvas(ctx: any, canvas: any, degrees: number) {
+  const radians = (degrees * Math.PI) / 180;
+  const newCanvas = createCanvas(canvas.width, canvas.height);
+  const newCtx = newCanvas.getContext("2d");
+
+  newCtx.translate(canvas.width / 2, canvas.height / 2);
+  newCtx.rotate(radians);
+  newCtx.drawImage(canvas, -canvas.width / 2, -canvas.height / 2);
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+  ctx.drawImage(newCanvas, 0, 0);
+}
+
+function adjustBrightness(ctx: any, value: number) {
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    pixels[i] += 255 * value;
+    pixels[i + 1] += 255 * value;
+    pixels[i + 2] += 255 * value;
+  }
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function adjustContrast(ctx: any, value: number) {
+  const factor = (259 * (value + 255)) / (255 * (259 - value));
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    pixels[i] = factor * (pixels[i] - 128) + 128;
+    pixels[i + 1] = factor * (pixels[i + 1] - 128) + 128;
+    pixels[i + 2] = factor * (pixels[i + 2] - 128) + 128;
+  }
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function invertColors(ctx: any) {
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    pixels[i] = 255 - pixels[i];
+    pixels[i + 1] = 255 - pixels[i + 1];
+    pixels[i + 2] = 255 - pixels[i + 2];
+  }
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function grayscale(ctx: any) {
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const avg = (pixels[i] + pixels[i + 1] + pixels[i + 2]) / 3;
+    pixels[i] = pixels[i + 1] = pixels[i + 2] = avg;
+  }
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function applySepia(ctx: any) {
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const r = pixels[i];
+    const g = pixels[i + 1];
+    const b = pixels[i + 2];
+
+    pixels[i] = r * 0.393 + g * 0.769 + b * 0.189;
+    pixels[i + 1] = r * 0.349 + g * 0.686 + b * 0.168;
+    pixels[i + 2] = r * 0.272 + g * 0.534 + b * 0.131;
+  }
+  ctx.putImageData(imageData, 0, 0);
+}
+
+
+function applyBlur(ctx: any, radius: number) {
+  if (radius <= 0) return;
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  const width = ctx.canvas.width;
+  const height = ctx.canvas.height;
+  
+  const blurSize = Math.floor(radius);
+  for (let y = blurSize; y < height - blurSize; y++) {
+    for (let x = blurSize; x < width - blurSize; x++) {
+      let r = 0, g = 0, b = 0, count = 0;
+      
+      for (let dy = -blurSize; dy <= blurSize; dy++) {
+        for (let dx = -blurSize; dx <= blurSize; dx++) {
+          const index = ((y + dy) * width + (x + dx)) * 4;
+          r += pixels[index];
+          g += pixels[index + 1];
+          b += pixels[index + 2];
+          count++;
+        }
+      }
+
+      const index = (y * width + x) * 4;
+      pixels[index] = r / count;
+      pixels[index + 1] = g / count;
+      pixels[index + 2] = b / count;
+    }
+  }
+
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function posterize(ctx: any, levels: number) {
+  if (levels < 2 || levels > 255) return;
+  const imageData = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+  const pixels = imageData.data;
+  const factor = 255 / (levels - 1);
+
+  for (let i = 0; i < pixels.length; i += 4) {
+    pixels[i] = Math.round(pixels[i] / factor) * factor;
+    pixels[i + 1] = Math.round(pixels[i + 1] / factor) * factor;
+    pixels[i + 2] = Math.round(pixels[i + 2] / factor) * factor;
+  }
+
+  ctx.putImageData(imageData, 0, 0);
+}
+
+function pixelate(ctx: any, size: number, startX = 0, startY = 0, width = ctx.canvas.width, height = ctx.canvas.height) {
+  if (size < 1) return;
+  const imageData = ctx.getImageData(startX, startY, width, height);
+  const pixels = imageData.data;
+
+  for (let y = 0; y < height; y += size) {
+    for (let x = 0; x < width; x += size) {
+      let r = 0, g = 0, b = 0, count = 0;
+      
+      for (let dy = 0; dy < size; dy++) {
+        for (let dx = 0; dx < size; dx++) {
+          if (x + dx < width && y + dy < height) {
+            const index = ((y + dy) * width + (x + dx)) * 4;
+            r += pixels[index];
+            g += pixels[index + 1];
+            b += pixels[index + 2];
+            count++;
+          }
+        }
+      }
+
+      r = Math.floor(r / count);
+      g = Math.floor(g / count);
+      b = Math.floor(b / count);
+
+      for (let dy = 0; dy < size; dy++) {
+        for (let dx = 0; dx < size; dx++) {
+          if (x + dx < width && y + dy < height) {
+            const index = ((y + dy) * width + (x + dx)) * 4;
+            pixels[index] = r;
+            pixels[index + 1] = g;
+            pixels[index + 2] = b;
+          }
+        }
+      }
+    }
+  }
+
+  ctx.putImageData(imageData, startX, startY);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apexify.js",
-  "version": "4.5.50",
+  "version": "4.5.51",
   "description": "Unlimited AI models and Canvas library. Supports ts & js (supports front/back end).",
   "author": "zenith-79",
   "license": "MIT",
@@ -43,6 +43,8 @@
     "custom ai",
     "openai",
     "ai",
+    "ai video",
+    "video generating",
     "image-vision",
     "vision",
     "image vision",
@@ -132,6 +134,11 @@
     "chat bot",
     "speech recognition",
     "voice message",
+    "text2speech",
+    "texttospeech",
+    "transcription",
+    "speech2text",
+    "speechtotext",
     "trained ai",
     "trained model",
     "image",
@@ -222,8 +229,6 @@
     "@iamtraction/google-translate": "^2.0.1",
     "@napi-rs/canvas": "^0.1.53",
     "axios": "^1.7.7",
-    "canvas": "^3.0.1",
-    "chart.js": "^4.4.7",
     "csv-parse": "^5.5.6",
     "discord.js": "^14.15.3",
     "fluent-ffmpeg": "^2.1.3",
@@ -232,11 +237,9 @@
     "groq-sdk": "^0.5.0",
     "hercai": "^12.4.0",
     "imgur": "^2.4.2",
-    "jimp": "^0.22.12",
     "openai": "^4.71.1",
     "pdf-parse": "^1.1.1",
-    "quickchart": "^1.1.4",
-    "sharp": "^0.33.4",
+    "sharp": "^0.33.5",
     "tesseract.js": "^5.1.0",
     "verse.db": "^2.2.15"
   },