<![CDATA[]]>
false
true
true
false
false
]]>
true
true
true
false
20
1
true
undefined
Var Table 1
true
false
VARIABLE_EDITOR
Var Table 2
true
false
undefined
init
true
false
= midX - midY) {
plottedPointsX.push(x);
plottedPointsY.push(y);
plottedPoints.push({
x,
y,
connected: []
})
}
}
}
}
break;
case "Diagonal (-)":
if (selectedSide === "Left") {
for (let x = 0; x <= graphX; x += tickSeparation) {
for (let y = 0; y <= graphY; y += tickSeparation) {
if (x + y <= midX + midY) {
plottedPointsX.push(x);
plottedPointsY.push(y);
plottedPoints.push({
x,
y,
connected: []
})
}
}
}
} else {
for (let x = 0; x <= graphX; x += tickSeparation) {
for (let y = 0; y <= graphY; y += tickSeparation) {
if (x + y >= midX + midY) {
plottedPointsX.push(x);
plottedPointsY.push(y);
plottedPoints.push({
x,
y,
connected: []
})
}
}
}
}
break;
default:
break;
}
selectedPlottedPoints = Array(plottedPointsX.length).fill(0);
}
]]>
CODE_EDITOR
onClickPlottedPoints
true
false
= midX - midY) {
mirroredPointsX.push(x);
mirroredPointsY.push(y);
mirroredPoints.push({
x,
y,
connected: []
})
}
}
}
} else {
for (let x = 0; x <= graphX; x += tickSeparation) {
for (let y = 0; y <= graphY; y += tickSeparation) {
if (x - y <= midX - midY) {
mirroredPointsX.push(x);
mirroredPointsY.push(y);
mirroredPoints.push({
x,
y,
connected: []
})
}
}
}
}
break;
case "Diagonal (-)":
if (selectedSide === "Left") {
for (let x = 0; x <= graphX; x += tickSeparation) {
for (let y = 0; y <= graphY; y += tickSeparation) {
if (x + y >= midX + midY) {
mirroredPointsX.push(x);
mirroredPointsY.push(y);
mirroredPoints.push({
x,
y,
connected: []
})
}
}
}
} else {
for (let x = 0; x <= graphX; x += tickSeparation) {
for (let y = 0; y <= graphY; y += tickSeparation) {
if (x + y <= midX + midY) {
mirroredPointsX.push(x);
mirroredPointsY.push(y);
mirroredPoints.push({
x,
y,
connected: []
})
}
}
}
}
break;
default:
break;
}
selectedMirroredPoints = Array(mirroredPointsX.length).fill(0);
}
]]>
CODE_EDITOR
onClickMirroredPoints
true
false
{
if (selectedSide === "Left") {
point.x = graphX - point.x;
} else {
point.x = graphX - point.x;
}
point.connected = point.connected.map(conn => ({
x: graphX - conn.x,
y: conn.y
}));
});
break;
case "Horizontal":
mirroredPoints.forEach(point => {
if (selectedSide === "Top") {
point.y = graphY - point.y;
} else {
point.y = graphY - point.y;
}
point.connected = point.connected.map(conn => ({
x: conn.x,
y: graphY - conn.y
}));
});
break;
case "Diagonal (+)":
mirroredPoints.forEach(point => {
if (selectedSide === "Left") {
const temp = point.x;
point.x = point.y;
point.y = temp;
} else {
const temp = point.x;
point.x = point.y;
point.y = temp;
}
point.connected = point.connected.map(conn => ({
x: conn.y,
y: conn.x
}));
});
break;
case "Diagonal (-)":
mirroredPoints.forEach(point => {
const reflectedX = graphX - point.y;
const reflectedY = graphY - point.x;
point.x = reflectedX;
point.y = reflectedY;
point.connected = point.connected.map(conn => {
const reflectedConnX = graphX - conn.y;
const reflectedConnY = graphY - conn.x;
return { x: reflectedConnX, y: reflectedConnY };
});
});
break;
default:
console.log("Invalid line selection.");
break;
}
console.log("Mirrored Points:", mirroredPoints);
const isEqual = processAndCompare(mirroredPoints, plottedPoints);
if (isEqual) {
alert("Success! The mirrored points match the original plotted points.");
} else {
alert("Try again! The mirrored points do not match.");
}
initMirroredPoints();
return mirroredPoints;
}
function breakConnections(points) {
const pointsMap = new Map();
points.forEach((point) => {
pointsMap.set(`${point.x},${point.y}`, { ...point, connected: [] });
});
const newPoints = [];
function gcd(a, b) {
return b === 0 ? Math.abs(a) : gcd(b, a % b);
}
points.forEach((point) => {
const originalConnections = [...point.connected];
originalConnections.forEach((connection) => {
const dx = connection.x - point.x;
const dy = connection.y - point.y;
const step = gcd(dx, dy);
const stepX = dx / step;
const stepY = dy / step;
let x = point.x;
let y = point.y;
let prevKey = `${x},${y}`;
while (x !== connection.x || y !== connection.y) {
x += stepX;
y += stepY;
const newPointKey = `${x},${y}`;
if (!pointsMap.has(newPointKey)) {
newPoints.push({ x, y, connected: [] });
pointsMap.set(newPointKey, { x, y, connected: [] });
}
const currentPoint = pointsMap.get(newPointKey);
const previousPoint = pointsMap.get(prevKey);
if (!currentPoint.connected.some((p) => p.x === previousPoint.x && p.y === previousPoint.y)) {
currentPoint.connected.push({ x: previousPoint.x, y: previousPoint.y });
}
if (!previousPoint.connected.some((p) => p.x === currentPoint.x && p.y === currentPoint.y)) {
previousPoint.connected.push({ x: currentPoint.x, y: currentPoint.y });
}
prevKey = newPointKey;
}
});
});
return Array.from(pointsMap.values());
}
function compareUnorderedPoints(arr1, arr2) {
if (arr1.length !== arr2.length) return false;
const sortedArr1 = arr1.slice().sort((a, b) => (a.x - b.x) || (a.y - b.y));
const sortedArr2 = arr2.slice().sort((a, b) => (a.x - b.x) || (a.y - b.y));
return sortedArr1.every((point1, index) => {
const point2 = sortedArr2[index];
if (point1.x !== point2.x || point1.y !== point2.y) return false;
const sortedConn1 = point1.connected.slice().sort((a, b) => (a.x - b.x) || (a.y - b.y));
const sortedConn2 = point2.connected.slice().sort((a, b) => (a.x - b.x) || (a.y - b.y));
if (sortedConn1.length !== sortedConn2.length) return false;
return sortedConn1.every((conn1, connIndex) => {
const conn2 = sortedConn2[connIndex];
return conn1.x === conn2.x && conn1.y === conn2.y;
});
});
}
function processAndCompare(arr1, arr2) {
const expandedArr1 = breakConnections(arr1);
const expandedArr2 = breakConnections(arr2);
console.log(expandedArr1);
console.log(expandedArr1);
return compareUnorderedPoints(expandedArr1, expandedArr2);
}
]]>
HTML_VIEW_EDITOR
HtmlView
true
false
0
0
0
800
600
true
true
Elements.Panel
true
Elements.Panel
Elements.Label
true
Elements.Panel
Elements.ComboBox
0)? opts[0]:"";
if (selectedLine === "Horizontal") {
sideOptions = ["Top", "Bottom"];
selectedSide = "Top";
} else {
sideOptions = ["Left", "Right"];
selectedSide = selectedSide === "Right" ? "Right" : "Left";
}
console.log(selectedLine, selectedSide);
initFunctions();]]>
Elements.ComboBox
0)? opts[0]:"";
console.log(selectedLine, selectedSide);
initFunctions();]]>
Elements.Button
Elements.Button
Elements.Button
Elements.Button
true
Elements.PlottingPanel
Elements.Segment2D
Elements.ShapeSet2D
Elements.SegmentSet2D
Elements.ShapeSet2D
Elements.SegmentSet2D