geometrix 0.5.10 → 0.5.12

package/src/arc_to_stroke.ts

@@ -1,73 +0,0 @@
-// arc_to_stroke.ts
-
-import { orientedArc } from './angle_utils';
-
-type tAtsPoints = [number, number][];
-
-function calcAngleStep(
-	max_angle: number,
-	max_length: number,
-	radius: number,
-	arc_angle: number
-): [number, number] {
-	let max_angle2 = Math.PI / 2;
-	if (max_length < 2 * radius) {
-		max_angle2 = 2 * Math.asin(max_length / (2 * radius));
-	}
-	const angleStepMax = Math.min(max_angle, max_angle2);
-	//const angleNb = Math.floor(arc_angle / angleStepMax) + 1;
-	const angleNb = Math.ceil(arc_angle / angleStepMax);
-	const angleStep = arc_angle / angleNb;
-	//console.log(`dbg783: ${arc_angle} ${angleStepMax} ${angleNb}`);
-	return [angleNb, angleStep];
-}
-
-function circle_to_stroke(
-	cx: number,
-	cy: number,
-	radius: number,
-	max_angle = Math.PI / 6,
-	max_length = 2.0
-): tAtsPoints {
-	const [angleNb, angleStep] = calcAngleStep(max_angle, max_length, radius, 2 * Math.PI);
-	const rPoints: tAtsPoints = [];
-	for (let i = 0; i < angleNb; i++) {
-		const px = cx + radius * Math.cos(i * angleStep);
-		const py = cy + radius * Math.sin(i * angleStep);
-		rPoints.push([px, py]);
-	}
-	// close the contour
-	const p0x = rPoints[0][0];
-	const p0y = rPoints[0][1];
-	rPoints.push([p0x, p0y]);
-	return rPoints;
-}
-
-function arc_to_stroke(
-	cx: number,
-	cy: number,
-	radius: number,
-	a1: number,
-	a2: number,
-	ccw: boolean,
-	max_angle = Math.PI / 6,
-	max_length = 2.0
-): tAtsPoints {
-	const arc_angle = orientedArc(a1, a2, ccw);
-	const [angleNb, angleStep] = calcAngleStep(max_angle, max_length, radius, Math.abs(arc_angle));
-	//console.log(`dbg054: ${angleNb} ${angleStep}`);
-	const angleStepSigned = ccw ? angleStep : -angleStep;
-	const angleNb2 = angleNb + 1; // pole and fence
-	const rPoints: tAtsPoints = [];
-	// skip first point
-	for (let i = 1; i < angleNb2; i++) {
-		const angle = a1 + i * angleStepSigned;
-		const px = cx + radius * Math.cos(angle);
-		const py = cy + radius * Math.sin(angle);
-		rPoints.push([px, py]);
-	}
-	return rPoints;
-}
-
-export type { tAtsPoints };
-export { circle_to_stroke, arc_to_stroke };

package/src/canvas_utils.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest';
-//import type { tCanvasAdjust };
-import {
-	colors,
-	point2canvas,
-	canvas2point,
-	//adjustZero,
-	adjustInit
-	//adjustCenter,
-	//adjustRect,
-	//adjustScale,
-	//adjustTranslate
-} from './canvas_utils';
-
-const cAdjust = adjustInit(0, 200, 0, 200, 200, 200);
-
-describe('canvas_utils', () => {
-	it('colors object', () => {
-		expect(colors).toHaveProperty('point');
-		expect(colors).not.toHaveProperty('blabla');
-	});
-	it('point2canvas function', () => {
-		expect(point2canvas(10, 20, cAdjust)).toEqual([19, 172]);
-	});
-	it('canvas2point function', () => {
-		expect(canvas2point(19, 172, cAdjust)).toEqual([10, 20]);
-	});
-});

package/src/canvas_utils.ts

@@ -1,159 +0,0 @@
-// canvas_utils.ts
-// helper interfaces and functions to work with HtmlCanvas
-// used by point.ts, line.ts, vector.ts, contour.ts and figure.ts
-
-import { roundZero } from './angle_utils';
-
-const colors = {
-	point: 'grey',
-	line: 'grey',
-	vector: 'DarkTurquoise',
-	contour: 'green',
-	main: 'SteelBlue',
-	mainB: 'SlateGrey',
-	second: 'Violet',
-	secondB: 'SlateGrey',
-	dynamics: 'Tomato',
-	ruler: 'blue',
-	origin: 'red',
-	reference: 'blue',
-	mouse: 'yellow'
-};
-
-interface tCanvasAdjust {
-	init: number;
-	xMin: number;
-	yMin: number;
-	xyDiff: number;
-	shiftX: number;
-	shiftY: number;
-	scaleX: number;
-	scaleY: number;
-}
-
-function point2canvas(px: number, py: number, iAdjust: tCanvasAdjust): [number, number] {
-	const cx2 = iAdjust.shiftX + (px - iAdjust.xMin) * iAdjust.scaleX;
-	const cy2 = iAdjust.shiftY + (py - iAdjust.yMin) * iAdjust.scaleY;
-	return [cx2, cy2];
-}
-function canvas2point(cx: number, cy: number, iAdjust: tCanvasAdjust): [number, number] {
-	const px2 = (cx - iAdjust.shiftX) / iAdjust.scaleX + iAdjust.xMin;
-	const py2 = (cy - iAdjust.shiftY) / iAdjust.scaleY + iAdjust.yMin;
-	return [px2, py2];
-}
-function canvasTranslatePolar(cx: number, cy: number, ia: number, il: number): [number, number] {
-	const cx2 = cx + il * Math.cos(ia);
-	const cy2 = cy - il * Math.sin(ia);
-	return [cx2, cy2];
-}
-function radius2canvas(iRadius: number, iAdjust: tCanvasAdjust): number {
-	if (roundZero(iAdjust.scaleX - Math.abs(iAdjust.scaleY)) !== 0) {
-		throw `err683: iAdjust.scaleX and scaleY differ ${iAdjust.scaleX} ${iAdjust.scaleY}`;
-	}
-	const rRadius = iRadius * iAdjust.scaleX;
-	return rRadius;
-}
-
-function adjustZero(): tCanvasAdjust {
-	const rAdjustZero = {
-		init: 0,
-		xMin: 0,
-		yMin: 0,
-		xyDiff: 1,
-		shiftX: 0,
-		shiftY: 0,
-		scaleX: 1,
-		scaleY: 1
-	};
-	return rAdjustZero;
-}
-function adjustInit(
-	xMin: number,
-	xMax: number,
-	yMin: number,
-	yMax: number,
-	cWidth: number,
-	cHeight: number
-): tCanvasAdjust {
-	const rAdjust: tCanvasAdjust = adjustZero();
-	const xDiff = Math.max(xMax - xMin, 1);
-	const yDiff = Math.max(yMax - yMin, 1);
-	const xScale = cWidth / xDiff;
-	const yScale = cHeight / yDiff;
-	let xyScale = 0.9 * xScale;
-	let xyDiff = xDiff;
-	if (yScale < xScale) {
-		xyScale = 0.9 * yScale;
-		xyDiff = yDiff;
-	}
-	rAdjust.init = 1;
-	rAdjust.xMin = xMin;
-	rAdjust.yMin = yMin;
-	rAdjust.xyDiff = xyDiff;
-	rAdjust.shiftX = 0.05 * cWidth;
-	rAdjust.scaleX = xyScale;
-	rAdjust.shiftY = cHeight - 0.05 * cHeight;
-	rAdjust.scaleY = -1 * xyScale;
-	return rAdjust;
-}
-function adjustCenter(px: number, py: number, iAdjust: tCanvasAdjust): tCanvasAdjust {
-	const rAdjust: tCanvasAdjust = structuredClone(iAdjust);
-	rAdjust.xMin = px - rAdjust.xyDiff / 2;
-	rAdjust.yMin = py - rAdjust.xyDiff / 2;
-	return rAdjust;
-}
-function adjustRect(
-	p1x: number,
-	p1y: number,
-	p2x: number,
-	p2y: number,
-	cWidth: number,
-	cHeight: number
-): tCanvasAdjust {
-	const xMin = Math.min(p1x, p2x);
-	const xMax = Math.max(p1x, p2x);
-	const yMin = Math.min(p1y, p2y);
-	const yMax = Math.max(p1y, p2y);
-	const rAdjust = adjustInit(xMin, xMax, yMin, yMax, cWidth, cHeight);
-	return rAdjust;
-}
-function adjustScale(iFactor: number, iAdjust: tCanvasAdjust): tCanvasAdjust {
-	const rAdjust: tCanvasAdjust = structuredClone(iAdjust);
-	const shift = (1 - iFactor) / 2;
-	rAdjust.xMin += shift * iAdjust.xyDiff;
-	rAdjust.yMin += shift * iAdjust.xyDiff;
-	rAdjust.xyDiff *= iFactor;
-	rAdjust.scaleX *= 1.0 / iFactor;
-	rAdjust.scaleY *= 1.0 / iFactor;
-	return rAdjust;
-}
-function adjustTranslate(
-	p1x: number,
-	p1y: number,
-	p2x: number,
-	p2y: number,
-	iAdjust: tCanvasAdjust
-): tCanvasAdjust {
-	const rAdjust: tCanvasAdjust = structuredClone(iAdjust);
-	const xDiff = p2x - p1x;
-	const yDiff = p2y - p1y;
-	//console.log(`dbg118: ${xDiff} ${yDiff}`);
-	rAdjust.xMin += -xDiff;
-	rAdjust.yMin += -yDiff;
-	return rAdjust;
-}
-
-export type { tCanvasAdjust };
-export {
-	colors,
-	point2canvas,
-	canvas2point,
-	canvasTranslatePolar,
-	radius2canvas,
-	adjustZero,
-	adjustInit,
-	adjustCenter,
-	adjustRect,
-	adjustScale,
-	adjustTranslate
-};

package/src/contour.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { point } from './point';
-import { contour, contourCircle } from './contour';
-
-describe('Contour suit', () => {
-	const ctr1 = contour(10, 10);
-	ctr1.addPointA(20, 20).addSegStroke();
-	ctr1.addPointA(20, 0).addSegStroke();
-	ctr1.closeSegStroke();
-	it('extractPoints', () => {
-		expect(ctr1.generatePoints()[0].isEqual(point(10, 10))).toBeTruthy();
-	});
-	it('generateContour', () => {
-		const ctr2 = ctr1.generateContour();
-		expect(ctr2.generatePoints()[0].isEqual(point(10, 10))).toBeTruthy();
-	});
-});
-
-describe('Contour suit 2', () => {
-	const ctr1 = contour(10, 10);
-	ctr1.addSegStrokeR(30, 30);
-	ctr1.addCornerPointed();
-	ctr1.addCornerPointed();
-	ctr1.addSegStrokeR(30, -30);
-	ctr1.closeSegStroke();
-	it('generateContour', () => {
-		expect(() => ctr1.generateContour()).toThrowError(/err419/);
-	});
-});
-
-describe('ContourCircle suit', () => {
-	const ctr3 = contourCircle(50, 50, 20);
-	it('extractPoints', () => {
-		expect(ctr3.generatePoints()[0].isEqual(point(50, 50))).toBeTruthy();
-		expect(ctr3.generatePoints()[1].isEqual(point(70, 50))).toBeTruthy();
-	});
-});