koishi-plugin-drf 0.0.3 → 0.0.5

package/lib/index.d.ts

@@ -1,15 +1,51 @@
-import { Context, Schema } from 'koishi';
+import { Context, Schema, h } from 'koishi';
+declare module 'koishi' {
+    interface Context {
+        canvas: CanvasService;
+    }
+}
+interface CanvasRenderingContext2D<C extends Canvas = Canvas, I extends Image = Image> extends Omit<globalThis.CanvasRenderingContext2D, 'drawImage' | 'canvas'> {
+    canvas: C;
+    drawImage(image: C | I, dx: number, dy: number): void;
+    drawImage(image: C | I, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: C | I, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+}
+interface Canvas {
+    width: number;
+    height: number;
+    getContext(type: '2d'): CanvasRenderingContext2D;
+    toBuffer(type: 'image/png'): Promise<Buffer>;
+    toDataURL(type: 'image/png'): Promise<string>;
+    dispose(): Promise<void>;
+}
+interface Image {
+    readonly naturalWidth: number;
+    readonly naturalHeight: number;
+    dispose(): Promise<void>;
+}
+declare abstract class CanvasService {
+    abstract createCanvas(width: number, height: number): Promise<Canvas>;
+    abstract loadImage(source: string | URL | Buffer | ArrayBufferLike): Promise<Image>;
+    render(width: number, height: number, callback: (ctx: CanvasRenderingContext2D) => Promise<void>): Promise<h>;
+}
 export declare const name = "function-plotter";
+export declare const using: readonly ["canvas"];
 export interface Config {
     width: number;
     height: number;
     xMin: number;
     xMax: number;
     step: number;
+    tMin: number;
+    tMax: number;
+    tSamples: number;
+    implicitResolution: number;
     backgroundColor: string;
     lineColor: string;
     gridColor: string;
     showGrid: boolean;
 }
+export declare const usage: string;
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -22,111 +22,365 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
-  name: () => name
+  name: () => name,
+  usage: () => usage,
+  using: () => using
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
-var import_canvas = require("canvas");
 var import_mathjs = require("mathjs");
 var name = "function-plotter";
+var using = ["canvas"];
+var usage = `
+### Math Forest 群聊用函数绘图器 使用说明
+
+#### 支持格式
+1. 显式函数(y= 可省略)
+  - x^2
+  - y = sin(x) + cos(x)
+  - x = y^2 - 3
+
+3. 隐函数(以 0= 开头)
+  - 0 = x^2 + y^2 - 1
+  - 0 = sin(x) - y
+
+4. 参数方程
+  - drf (t)[t * cos(3 * t), t * sin(3 * t)]
+
+#### 缩放参数
+@数值  -> 坐标范围为 [-n, n]
+
+#### 示例
+- drf x^3 @30
+- drf 0 = x^2+y^2-25
+- drf (t)[t * cos(t), t * sin(t)] @15
+
+---
+
+#### 关于
+\`\`\`
+
+Duo : https://www.mduo.cloud/
+Math Forest : 663251235
+\`\`\`
+
+`.trim();
 var Config = import_koishi.Schema.object({
-  width: import_koishi.Schema.number().default(600).description("宽度"),
-  height: import_koishi.Schema.number().default(600).description("高度"),
-  xMin: import_koishi.Schema.number().default(-10).description("X轴始值"),
-  xMax: import_koishi.Schema.number().default(10).description("X轴终值"),
-  step: import_koishi.Schema.number().default(0.1).description("步长"),
-  backgroundColor: import_koishi.Schema.string().default("white").description("背景色"),
-  lineColor: import_koishi.Schema.string().default("navy").description("线条颜色,例如red，green，blue，cyan，teal，maroon"),
-  gridColor: import_koishi.Schema.string().default("#e0e0e0").description("网格色"),
+  width: import_koishi.Schema.number().default(600).description("图像宽度"),
+  height: import_koishi.Schema.number().default(600).description("图像高度"),
+  xMin: import_koishi.Schema.number().default(-10).description("X轴默认最小值"),
+  xMax: import_koishi.Schema.number().default(10).description("X轴默认最大值"),
+  step: import_koishi.Schema.number().default(0.05).description("显式函数步长"),
+  tMin: import_koishi.Schema.number().default(-10).description("参数方程 t 的最小值"),
+  tMax: import_koishi.Schema.number().default(10).description("参数方程 t 的最大值"),
+  tSamples: import_koishi.Schema.number().default(3e3).description("参数方程采样数"),
+  implicitResolution: import_koishi.Schema.number().default(400).description("隐函数网格精度"),
+  backgroundColor: import_koishi.Schema.string().default("white").description("背景颜色"),
+  lineColor: import_koishi.Schema.string().default("blue").description("线条颜色"),
+  gridColor: import_koishi.Schema.string().default("#e0e0e0").description("网格颜色"),
   showGrid: import_koishi.Schema.boolean().default(true).description("显示网格")
 });
 function apply(ctx, config) {
-  ctx.command("drf <expression>", "绘制函数图像").alias("函数绘图").example("drf f(x)=x^2").action(async ({ session }, expression) => {
+  if (!ctx.canvas) {
+    ctx.logger.warn("canvas 插件未安装，函数绘图功能将不可用");
+    return;
+  }
+  ctx.command("drf <expression:text>", "绘制函数图像").alias("函数绘图").example("drf y=x^2 @100").action(async ({ session }, expression) => {
     if (!expression) {
-      return "[color提醒您]不给我表达式怎麽画(*´･д･)?";
+      return "mf群聊绘图器0.1.3\n示例输入：\ndrf x^2\ndrf 0=x^2+y^2-1\ndrf (t)[cos(t), sin(t)]\n(在末尾加上 @数值 来设置缩放，例如：drf x^3 @100)";
+    }
+    const originalExpression = expression.trim();
+    let rawExpr = originalExpression;
+    let dynamicXMin = config.xMin;
+    let dynamicXMax = config.xMax;
+    const scaleMatch = rawExpr.match(/^(.*?)\s*@\s*([\d.]+)\s*$/);
+    if (scaleMatch) {
+      rawExpr = scaleMatch[1].trim();
+      const scale = parseFloat(scaleMatch[2]);
+      if (!isNaN(scale) && scale > 0) {
+        dynamicXMin = -scale;
+        dynamicXMax = scale;
+      }
+    }
+    if (dynamicXMax <= dynamicXMin) {
+      return "X轴最大值必须大于最小值。";
+    }
+    let plotType = "explicit_y";
+    let eq1 = "", eq2 = "";
+    const paramMatch = rawExpr.match(/^\(t\)\s*\[\s*(.*?)\s*,\s*(.*?)\s*\]$/);
+    if (paramMatch) {
+      plotType = "parametric";
+      eq1 = paramMatch[1];
+      eq2 = paramMatch[2];
+    } else if (rawExpr.startsWith("0=") || rawExpr.startsWith("0 =")) {
+      plotType = "implicit";
+      eq1 = rawExpr.replace(/^0\s*=\s*/, "");
+    } else if (rawExpr.startsWith("x=") || rawExpr.startsWith("x =")) {
+      plotType = "explicit_x";
+      eq1 = rawExpr.replace(/^x\s*=\s*/, "");
+    } else {
+      plotType = "explicit_y";
+      eq1 = rawExpr.replace(/^y\s*=\s*/, "");
     }
     try {
-      const compiled = (0, import_mathjs.compile)(expression);
-      const scope = { x: 0 };
-      const canvas = (0, import_canvas.createCanvas)(config.width, config.height);
-      const ctxCanvas = canvas.getContext("2d");
-      ctxCanvas.fillStyle = config.backgroundColor;
-      ctxCanvas.fillRect(0, 0, config.width, config.height);
-      const xAxis = config.height / 2;
-      const yAxis = config.width / 2;
-      const xScale = config.width / (config.xMax - config.xMin);
-      const yScale = config.height / 20;
-      if (config.showGrid) {
-        ctxCanvas.strokeStyle = config.gridColor;
-        ctxCanvas.lineWidth = 1;
-        for (let x = Math.ceil(config.xMin); x <= config.xMax; x++) {
-          if (x === 0) continue;
-          const xPos = yAxis + x * xScale;
+      return await ctx.canvas.render(config.width, config.height, async (ctxCanvas) => {
+        const xrange = dynamicXMax - dynamicXMin;
+        const yrange = xrange * (config.height / config.width);
+        const yMid = 0;
+        const yMin = yMid - yrange / 2;
+        const yMax = yMid + yrange / 2;
+        const w2sX = /* @__PURE__ */ __name((x) => (x - dynamicXMin) / xrange * config.width, "w2sX");
+        const w2sY = /* @__PURE__ */ __name((y) => config.height - (y - yMin) / yrange * config.height, "w2sY");
+        ctxCanvas.fillStyle = config.backgroundColor;
+        ctxCanvas.fillRect(0, 0, config.width, config.height);
+        const getNiceStep = /* @__PURE__ */ __name((range, targetTicks2) => {
+          const rawStep = range / targetTicks2;
+          const mag = Math.floor(Math.log10(rawStep));
+          const magPow = Math.pow(10, mag);
+          const frac = rawStep / magPow;
+          let niceFrac = 10;
+          if (frac < 1.5) niceFrac = 1;
+          else if (frac < 3) niceFrac = 2;
+          else if (frac < 7) niceFrac = 5;
+          return niceFrac * magPow;
+        }, "getNiceStep");
+        const formatNumber = /* @__PURE__ */ __name((num) => {
+          if (num === 0) return "0";
+          const abs = Math.abs(num);
+          if (abs >= 1e5 || abs <= 1e-4) {
+            let [mantissa, exponent] = num.toExponential(2).split("e");
+            mantissa = parseFloat(mantissa).toString();
+            exponent = exponent.replace("+", "");
+            return `${mantissa}e${exponent}`;
+          }
+          return parseFloat(num.toPrecision(10)).toString();
+        }, "formatNumber");
+        const targetTicks = Math.max(4, Math.floor(config.width / 80));
+        const tickStep = getNiceStep(xrange, targetTicks);
+        const startX = Math.ceil(dynamicXMin / tickStep);
+        const endX = Math.floor(dynamicXMax / tickStep);
+        const startY = Math.ceil(yMin / tickStep);
+        const endY = Math.floor(yMax / tickStep);
+        const originX = w2sX(0);
+        const originY = w2sY(0);
+        if (config.showGrid) {
+          ctxCanvas.strokeStyle = config.gridColor;
+          ctxCanvas.lineWidth = 1;
           ctxCanvas.beginPath();
-          ctxCanvas.moveTo(xPos, 0);
-          ctxCanvas.lineTo(xPos, config.height);
+          for (let i = startX; i <= endX; i++) {
+            if (i === 0) continue;
+            const px = w2sX(i * tickStep);
+            ctxCanvas.moveTo(px, 0);
+            ctxCanvas.lineTo(px, config.height);
+          }
+          for (let i = startY; i <= endY; i++) {
+            if (i === 0) continue;
+            const py = w2sY(i * tickStep);
+            ctxCanvas.moveTo(0, py);
+            ctxCanvas.lineTo(config.width, py);
+          }
           ctxCanvas.stroke();
         }
-        for (let y = -10; y <= 10; y++) {
-          if (y === 0) continue;
-          const yPos = xAxis - y * yScale;
-          ctxCanvas.beginPath();
-          ctxCanvas.moveTo(0, yPos);
-          ctxCanvas.lineTo(config.width, yPos);
-          ctxCanvas.stroke();
+        ctxCanvas.strokeStyle = "black";
+        ctxCanvas.lineWidth = 2;
+        ctxCanvas.beginPath();
+        if (originY >= 0 && originY <= config.height) {
+          ctxCanvas.moveTo(0, originY);
+          ctxCanvas.lineTo(config.width, originY);
         }
-      }
-      ctxCanvas.strokeStyle = "black";
-      ctxCanvas.lineWidth = 2;
-      ctxCanvas.beginPath();
-      ctxCanvas.moveTo(0, xAxis);
-      ctxCanvas.lineTo(config.width, xAxis);
-      ctxCanvas.stroke();
-      ctxCanvas.beginPath();
-      ctxCanvas.moveTo(yAxis, 0);
-      ctxCanvas.lineTo(yAxis, config.height);
-      ctxCanvas.stroke();
-      ctxCanvas.fillStyle = "black";
-      ctxCanvas.font = "12px Arial";
-      ctxCanvas.fillText("X", config.width - 15, xAxis - 5);
-      ctxCanvas.fillText("Y", yAxis + 5, 15);
-      ctxCanvas.strokeStyle = config.lineColor;
-      ctxCanvas.lineWidth = 3;
-      ctxCanvas.beginPath();
-      let isFirstPoint = true;
-      for (let x = config.xMin; x <= config.xMax; x += config.step) {
-        scope.x = x;
-        let y;
-        try {
-          y = compiled.evaluate(scope);
-          if (typeof y !== "number" || !isFinite(y)) {
-            isFirstPoint = true;
-            continue;
-          }
-          if (y < -100) y = -100;
-          if (y > 100) y = 100;
-          const xPixel = yAxis + x * xScale;
-          const yPixel = xAxis - y * yScale;
-          if (isFirstPoint) {
-            ctxCanvas.moveTo(xPixel, yPixel);
-            isFirstPoint = false;
+        if (originX >= 0 && originX <= config.width) {
+          ctxCanvas.moveTo(originX, 0);
+          ctxCanvas.lineTo(originX, config.height);
+        }
+        ctxCanvas.stroke();
+        const clamp = /* @__PURE__ */ __name((val, min, max) => Math.max(min, Math.min(max, val)), "clamp");
+        const labelOriginY = clamp(originY, 20, config.height - 20);
+        const labelOriginX = clamp(originX, 20, config.width - 20);
+        ctxCanvas.fillStyle = "black";
+        ctxCanvas.font = "12px Arial";
+        ctxCanvas.textAlign = "center";
+        ctxCanvas.textBaseline = "top";
+        for (let i = startX; i <= endX; i++) {
+          if (i === 0) continue;
+          const x = i * tickStep;
+          ctxCanvas.fillText(formatNumber(x), w2sX(x), labelOriginY + 5);
+        }
+        for (let i = startY; i <= endY; i++) {
+          if (i === 0) continue;
+          const y = i * tickStep;
+          if (labelOriginX < 30) {
+            ctxCanvas.textAlign = "left";
+            ctxCanvas.textBaseline = "middle";
+            ctxCanvas.fillText(formatNumber(y), labelOriginX + 5, w2sY(y));
           } else {
-            ctxCanvas.lineTo(xPixel, yPixel);
+            ctxCanvas.textAlign = "right";
+            ctxCanvas.textBaseline = "middle";
+            ctxCanvas.fillText(formatNumber(y), labelOriginX - 5, w2sY(y));
           }
-        } catch (error) {
-          isFirstPoint = true;
-          continue;
         }
-      }
-      ctxCanvas.stroke();
-      ctxCanvas.fillStyle = "#333";
-      ctxCanvas.font = "bold 16px Arial";
-      ctxCanvas.textAlign = "center";
-      ctxCanvas.fillText("draw by mf[color]: " + expression, config.width / 2, 25);
-      const buffer = canvas.toBuffer("image/png");
-      return import_koishi.h.image(buffer, "image/png");
+        ctxCanvas.textAlign = labelOriginX < 30 ? "left" : "right";
+        ctxCanvas.textBaseline = "top";
+        ctxCanvas.fillText("0", labelOriginX < 30 ? labelOriginX + 5 : labelOriginX - 5, labelOriginY + 5);
+        ctxCanvas.font = "italic bold 14px Arial";
+        ctxCanvas.textAlign = "right";
+        ctxCanvas.textBaseline = "bottom";
+        if (originY >= 0 && originY <= config.height) {
+          ctxCanvas.fillText("x", config.width - 15, originY - 5);
+        }
+        ctxCanvas.textAlign = "left";
+        ctxCanvas.textBaseline = "top";
+        if (originX >= 0 && originX <= config.width) {
+          ctxCanvas.fillText("y", originX + 5, 15);
+        }
+        ctxCanvas.strokeStyle = config.lineColor;
+        ctxCanvas.lineWidth = 2;
+        ctxCanvas.lineJoin = "round";
+        ctxCanvas.lineCap = "round";
+        ctxCanvas.beginPath();
+        if (plotType === "explicit_y" || plotType === "explicit_x") {
+          const compiled = (0, import_mathjs.compile)(eq1);
+          const scope = {};
+          const ASYMPTOTE_THRESHOLD = yrange * 10;
+          const defaultRange = config.xMax - config.xMin;
+          const plotStep = config.step * (xrange / defaultRange);
+          let first = true;
+          let prevV = 0;
+          const isY = plotType === "explicit_y";
+          const loopMin = isY ? dynamicXMin : yMin;
+          const loopMax = isY ? dynamicXMax : yMax;
+          for (let i = loopMin; i <= loopMax; i += plotStep) {
+            scope[isY ? "x" : "y"] = i;
+            try {
+              let v = compiled.evaluate(scope);
+              if (typeof v !== "number" || !isFinite(v)) {
+                first = true;
+                continue;
+              }
+              if (!first && Math.abs(v - prevV) > ASYMPTOTE_THRESHOLD) {
+                first = true;
+              }
+              const px = w2sX(isY ? i : v);
+              const py = w2sY(isY ? v : i);
+              if (first) {
+                ctxCanvas.moveTo(px, py);
+                first = false;
+              } else {
+                ctxCanvas.lineTo(px, py);
+              }
+              prevV = v;
+            } catch (e) {
+              first = true;
+            }
+          }
+          ctxCanvas.stroke();
+        } else if (plotType === "parametric") {
+          const compX = (0, import_mathjs.compile)(eq1);
+          const compY = (0, import_mathjs.compile)(eq2);
+          const scope = { t: 0 };
+          const tMin = config.tMin;
+          const tMax = config.tMax;
+          if (tMax <= tMin) throw new Error("t 的最大值必须大于最小值");
+          const tLen = tMax - tMin;
+          const totalSamples = config.tSamples;
+          const stepT = tLen / totalSamples;
+          const JUMP_THRESHOLD_FACTOR = 2;
+          const maxJumpDistSq = Math.pow(yrange * JUMP_THRESHOLD_FACTOR, 2);
+          let first = true;
+          let prevWX = 0, prevWY = 0;
+          for (let i = 0; i <= totalSamples; i++) {
+            scope.t = tMin + i * stepT;
+            try {
+              let wx = compX.evaluate(scope);
+              let wy = compY.evaluate(scope);
+              if (!isFinite(wx) || !isFinite(wy)) {
+                first = true;
+                continue;
+              }
+              if (!first) {
+                const dx = wx - prevWX;
+                const dy = wy - prevWY;
+                if (dx * dx + dy * dy > maxJumpDistSq) {
+                  first = true;
+                }
+              }
+              const px = w2sX(wx);
+              const py = w2sY(wy);
+              if (first) {
+                ctxCanvas.moveTo(px, py);
+                first = false;
+              } else {
+                ctxCanvas.lineTo(px, py);
+              }
+              prevWX = wx;
+              prevWY = wy;
+            } catch (e) {
+              first = true;
+            }
+          }
+          ctxCanvas.stroke();
+        } else if (plotType === "implicit") {
+          const compiled = (0, import_mathjs.compile)(eq1);
+          const scope = { x: 0, y: 0 };
+          const gridW = config.implicitResolution;
+          const gridH = Math.floor(gridW * (config.height / config.width));
+          const stepX = xrange / gridW;
+          const stepY = yrange / gridH;
+          const epsX = stepX * 13249e-7;
+          const epsY = stepY * 17381e-7;
+          const values = new Float64Array((gridW + 1) * (gridH + 1));
+          for (let i = 0; i <= gridW; i++) {
+            scope.x = dynamicXMin + i * stepX + epsX;
+            for (let j = 0; j <= gridH; j++) {
+              scope.y = yMin + j * stepY + epsY;
+              try {
+                let v = compiled.evaluate(scope);
+                values[i * (gridH + 1) + j] = typeof v === "number" && isFinite(v) ? v : NaN;
+              } catch (e) {
+                values[i * (gridH + 1) + j] = NaN;
+              }
+            }
+          }
+          const interp = /* @__PURE__ */ __name((v0, v1) => {
+            const diff = v1 - v0;
+            if (Math.abs(diff) < 1e-15) return 0.5;
+            return Math.max(0, Math.min(1, -v0 / diff));
+          }, "interp");
+          for (let i = 0; i < gridW; i++) {
+            const wx = dynamicXMin + i * stepX + epsX;
+            for (let j = 0; j < gridH; j++) {
+              const wy = yMin + j * stepY + epsY;
+              const v00 = values[i * (gridH + 1) + j];
+              const v10 = values[(i + 1) * (gridH + 1) + j];
+              const v01 = values[i * (gridH + 1) + (j + 1)];
+              const v11 = values[(i + 1) * (gridH + 1) + (j + 1)];
+              if (isNaN(v00) || isNaN(v10) || isNaN(v01) || isNaN(v11)) continue;
+              const pts = [];
+              if (v00 * v10 <= 0) pts.push([wx + interp(v00, v10) * stepX, wy]);
+              if (v10 * v11 <= 0) pts.push([wx + stepX, wy + interp(v10, v11) * stepY]);
+              if (v01 * v11 <= 0) pts.push([wx + interp(v01, v11) * stepX, wy + stepY]);
+              if (v00 * v01 <= 0) pts.push([wx, wy + interp(v00, v01) * stepY]);
+              if (pts.length === 2) {
+                ctxCanvas.moveTo(w2sX(pts[0][0]), w2sY(pts[0][1]));
+                ctxCanvas.lineTo(w2sX(pts[1][0]), w2sY(pts[1][1]));
+              } else if (pts.length === 4) {
+                ctxCanvas.moveTo(w2sX(pts[0][0]), w2sY(pts[0][1]));
+                ctxCanvas.lineTo(w2sX(pts[1][0]), w2sY(pts[1][1]));
+                ctxCanvas.moveTo(w2sX(pts[2][0]), w2sY(pts[2][1]));
+                ctxCanvas.lineTo(w2sX(pts[3][0]), w2sY(pts[3][1]));
+              }
+            }
+          }
+          ctxCanvas.stroke();
+        }
+        ctxCanvas.fillStyle = "#333";
+        ctxCanvas.font = "bold 16px Arial";
+        ctxCanvas.textAlign = "center";
+        ctxCanvas.textBaseline = "bottom";
+        ctxCanvas.fillText(`mf-draw: ${originalExpression}`, config.width / 2, 25);
+      });
     } catch (error) {
-      return `绘制函数图像时出错: ${error.message}`;
+      ctx.logger.error("绘制函数图像时出错:", error);
+      return `呜！错误：「${error.message}」~哈！！`;
     }
   });
 }
@@ -135,5 +389,7 @@ __name(apply, "apply");
 0 && (module.exports = {
   Config,
   apply,
-  name
+  name,
+  usage,
+  using
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-drf",
   "description": "draw math function in your group",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -3,3 +3,38 @@
 [![npm](https://img.shields.io/npm/v/koishi-plugin-drf?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-drf)
 
 draw math function in your group
+
+---
+
+### Math Forest 群聊用函数绘图器 使用说明
+
+#### 支持格式
+1. 显式函数(y= 可省略)
+  - x^2
+  - y = sin(x) + cos(x)
+  - x = y^2 - 3
+
+3. 隐函数(以 0= 开头)
+  - 0 = x^2 + y^2 - 1
+  - 0 = sin(x) - y
+
+4. 参数方程
+  - drf (t)[t * cos(3 * t), t * sin(3 * t)]
+
+#### 缩放参数
+@数值  -> 坐标范围为 [-n, n]
+
+#### 示例
+- drf sin(x) @30
+- drf 0 = x^2+y^2-25
+- drf (t)[t * cos(t), t * sin(t)] @15
+- drf (t)[(16*sin(t)^3), (13*cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t))] @20
+
+---
+
+#### 关于
+```
+
+Duo : https://www.mduo.cloud/
+Math Forest : 663251235
+```