chenlin/Mujoco_WASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3bbb5489910769f225baaed618263ce3ca2cb645
Mujoco_WASM/wasm/tests/bindings_test.ts
T
MatiasManevi c6564b1f79 Change package name and artefacts
2026-02-23 17:40:29 -03:00

2562 lines
84 KiB
TypeScript
Raw Blame History

// Copyright 2025 DeepMind Technologies Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import 'jasmine';
import {MainModule, MjContact, MjContactVec, MjData, MjLROpt, MjModel,
MjOption, MjsGeom, MjSolverStat, MjSpec, MjStatistic, MjTimerStat, MjvCamera,
MjvFigure, MjvGeom, MjvGLCamera, MjvLight, MjvOption, MjvPerturb, MjvScene,
MjWarningStat, MjVFS, Uint8Buffer} from '../dist/mujoco.js';
import loadMujoco from '../dist/mujoco.js'
function assertExists<T>(value: T | null | undefined, message?: string):
asserts value is T {
if (value === null || value === undefined) {
throw new Error(message ?? 'Expected value to be defined.');
}
}
// Corresponds to bindings_test.py:TEST_XML
const TEST_XML = `
<mujoco model="test">
<compiler coordinate="local" angle="radian" eulerseq="xyz"/>
<size nkey="2"/>
<option timestep="0.002" gravity="0 0 -9.81"/>
<visual>
<global fovy="50" />
<quality shadowsize="51" />
</visual>
<worldbody>
<geom name="myplane" type="plane" size="10 10 1" user="1 2 3"/>
<body name="mybox" pos="0 0 0.1">
<geom name="mybox" type="box" size="0.1 0.1 0.1" mass="0.25"/>
<freejoint name="myfree"/>
</body>
<body name="myhinge-body" pos="0 0 1">
<inertial pos="0 0 0" mass="1" diaginertia="1 1 1"/>
<site pos="0 0 -1" name="mysite" type="sphere"/>
<joint name="myhinge" type="hinge" axis="0 1 0" damping="1"/>
</body>
<body name="myball-body" pos="2 0 1">
<inertial pos="0 0 0" mass="1" diaginertia="1 1 1"/>
<joint name="myball" type="ball"/>
</body>
<body name="mocap-body" mocap="true" pos="42 0 42">
<geom name="mocap-sphere" type="sphere" size="0.1"/>
</body>
</worldbody>
<actuator>
<position name="myactuator" joint="myhinge"/>
</actuator>
<sensor>
<jointvel name="myjointvel" joint="myhinge"/>
<accelerometer name="myaccelerometer" site="mysite"/>
</sensor>
</mujoco>
`;
type TypedArray =|Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|
Int32Array|Uint32Array|Float32Array|Float64Array;
function norm(arr: number[]): number {
return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
}
function expectArraysClose(arr1: any, arr2: TypedArray, precision = 1) {
expect(arr1.length).toEqual(arr2.length);
for (let i = 0; i < arr1.length; i++) {
expect(arr1[i]).toBeCloseTo(arr2[i], precision);
}
}
function expectArraysEqual(arr1: any, arr2: TypedArray) {
expect(arr1.length).toEqual(arr2.length);
for (let i = 0; i < arr1.length; i++) {
expect(arr1[i]).toEqual(arr2[i]);
}
}
describe('MuJoCo WASM Bindings', () => {
let mujoco: MainModule;
let model: MjModel|null = null;
let data: MjData|null = null;
beforeAll(async () => {
mujoco = await loadMujoco();
});
function unlinkXMLFile(filename: string) {
try {
(mujoco as any).FS.unlink(filename);
} catch (e) {
console.warn(`Failed to unlink temporary XML file: ${e}`);
}
}
function writeXMLFile(filename: string, xmlContent: string) {
try {
(mujoco as any).FS.writeFile(filename, xmlContent);
} catch (e) {
throw new Error(`Failed to write temporary XML file: ${e}`);
}
}
beforeEach(() => {
const tempXmlFilename = '/tmp/model.xml';
writeXMLFile(tempXmlFilename, TEST_XML);
model = mujoco.MjModel!.mj_loadXML(tempXmlFilename);
if (!model) {
unlinkXMLFile(tempXmlFilename);
throw new Error('Failed to load model from XML');
}
unlinkXMLFile(tempXmlFilename);
data = new mujoco.MjData(model);
if (!data) {
throw new Error('Failed to create data from model');
}
});
afterEach(() => {
model?.delete();
data?.delete();
});
describe('Buffer API', () => {
it('should construct from an element count', () => {
const buf = new mujoco.DoubleBuffer(5);
expect(buf.GetElementCount()).toBe(5);
expect(buf.GetPointer()).toBeDefined();
expect(buf.GetView()).toBeDefined();
});
it('should construct from a Javascript array', () => {
const array: number[] = [0, 1, 4, 9, 16];
const buf = mujoco.DoubleBuffer.FromArray(array);
expect(buf.GetElementCount()).toBe(5);
expect(buf.GetPointer()).toBeDefined();
expect(buf.GetView()).toBeDefined();
expectArraysClose(buf.GetView(), new Float64Array(array));
});
it('should construct from Float64Array', () => {
const array = new Float64Array([1 / 11, 7 / 11]);
const buf = mujoco.DoubleBuffer.FromArray(array);
expect(buf.GetElementCount()).toBe(2);
expect(buf.GetPointer()).toBeDefined();
expect(buf.GetView()).toBeDefined();
expectArraysClose(buf.GetView(), array);
});
});
describe('mj_addM', () => {
let simpleModel: MjModel|null = null;
let simpleData: MjData|null = null;
const tempXmlFilename = '/tmp/simple_model.xml';
// A simpler model with nv=1 and nM=1 to avoid WASM binding bugs.
const simpleXmlContent = `
<mujoco>
<worldbody>
<body name="box" pos="0 0 0.5">
<joint type="slide" axis="1 0 0"/>
<geom type="box" size="0.1 0.1 0.1" mass="1"/>
</body>
</worldbody>
</mujoco>`;
beforeEach(() => {
writeXMLFile(tempXmlFilename, simpleXmlContent);
simpleModel = mujoco.MjModel!.mj_loadXML(tempXmlFilename);
assertExists(simpleModel);
simpleData = new mujoco.MjData(simpleModel);
assertExists(simpleData);
});
afterEach(() => {
simpleModel?.delete();
simpleData?.delete();
unlinkXMLFile(tempXmlFilename);
});
it('should compute the sparse inertia matrix', () => {
const nM = simpleModel!.nM;
const dstSparse = new mujoco.DoubleBuffer(nM);
try {
mujoco.mj_forward(simpleModel!, simpleData!);
mujoco.mj_addM(
simpleModel!, simpleData!, dstSparse, simpleModel!.M_rownnz,
simpleModel!.M_rowadr, simpleModel!.M_colind);
expect(dstSparse.GetView().length).toBe(1);
expect(dstSparse.GetView()[0]).toBeCloseTo(1.0);
} finally {
dstSparse.delete();
}
});
it('should throw an error for incorrect sparse matrix dimensions', () => {
const nM = simpleModel!.nM;
const dstSparse = new mujoco.DoubleBuffer(nM + 1);
try {
expect(
() => mujoco.mj_addM(
simpleModel!, simpleData!, dstSparse, simpleModel!.M_rownnz,
simpleModel!.M_rowadr, simpleModel!.M_colind))
.toThrowError(
'MuJoCo Error: [mj_addM] dst must have size 1, got 2');
} finally {
dstSparse.delete();
}
});
it('should compute the sparse inertia matrix with null pointers', () => {
const nM = simpleModel!.nM;
const dstSparse = new mujoco.DoubleBuffer(nM);
try {
mujoco.mj_forward(simpleModel!, simpleData!);
mujoco.mj_addM(simpleModel!, simpleData!, dstSparse, null, null, null);
expect(dstSparse.GetView().length).toBe(1);
} finally {
dstSparse.delete();
}
});
});
it('should compute geom distance without returning fromto', () => {
mujoco.mj_forward(model!, data!);
const dist = mujoco.mj_geomDistance(model!, data!, 0, 2, 200, null);
expect(dist).toEqual(41.9);
});
it('should handle box QP solver with null optionals', () => {
const n = 5;
const res = new mujoco.DoubleBuffer(n);
const r = new mujoco.DoubleBuffer(n * (n + 7));
const h = new mujoco.DoubleBuffer(n * n);
const g = mujoco.DoubleBuffer.FromArray(new Array(n).fill(1));
try {
for (let i = 0; i < n; i++) {
h.GetView()[i * (n + 1)] = 1;
}
const rank = mujoco.mju_boxQP(
res, r, null, h.GetView(), g.GetView(), null as any, null as any);
expect(rank).toBeGreaterThan(-1);
} finally {
res.delete();
r.delete();
h.delete();
g.delete();
}
});
// Corresponds to engine_core_constraint_test.cc:TEST_F(CoreConstraintTest,
// ConstraintUpdateImpl)
it('should correctly compute constraint cost', () => {
const xmlString = `
<mujoco>
<option>
<flag island="enable"/>
</option>
<default>
<geom size=".1"/>
</default>
<visual>
<headlight diffuse=".9 .9 .9"/>
</visual>
<worldbody>
<body>
<joint type="slide" axis="0 0 1" range="0 1" limited="true"/>
<geom/>
</body>
<body pos=".25 0 0">
<joint type="slide" axis="1 0 0"/>
<geom/>
</body>
<body pos="0 0 0.25">
<joint type="slide" axis="0 0 1"/>
<geom/>
<body pos="0 -.15 0">
<joint name="hinge1" axis="0 1 0"/>
<geom type="capsule" size="0.03" fromto="0 0 0 -.2 0 0"/>
<body pos="-.2 0 0">
<joint axis="0 1 0"/>
<geom type="capsule" size="0.03" fromto="0 0 0 -.2 0 0"/>
</body>
</body>
</body>
<body pos=".5 0 0">
<joint type="slide" axis="0 0 1" frictionloss="15"/>
<geom type="box" size=".08 .08 .02" euler="0 10 0"/>
</body>
<body pos="-.5 0 0">
<joint axis="0 1 0" frictionloss=".01"/>
<geom type="capsule" size="0.03" fromto="0 0 0 -.2 0 0"/>
</body>
<body pos="0 0 .5">
<joint name="hinge2" axis="0 1 0"/>
<geom type="box" size=".08 .02 .08"/>
</body>
<body pos=".5 0 .1">
<freejoint/>
<geom type="box" size=".03 .03 .03" pos="0.01 0.01 0.01"/>
</body>
<site name="0" pos="-.45 -.05 .35"/>
<body pos="-.5 0 .3" name="connect">
<freejoint/>
<geom type="box" size=".05 .05 .05"/>
<site name="1" pos=".05 -.05 .05"/>
</body>
</worldbody>
<equality>
<joint joint1="hinge1" joint2="hinge2"/>
<connect body1="connect" body2="world" anchor="-.05 -.05 .05"/>
<connect site1="0" site2="1"/>
</equality>
</mujoco>
`;
const tempXmlFilename = '/tmp/model_c.xml';
writeXMLFile(tempXmlFilename, xmlString);
const model = mujoco.MjModel!.mj_loadXML(tempXmlFilename);
expect(model).not.toBeNull();
const data = new mujoco.MjData(model!);
expect(data).not.toBeNull();
unlinkXMLFile(tempXmlFilename);
try {
mujoco.mj_resetData(model, data!);
let steps = 0;
while (data!.ncon === 0 && steps < 100) {
mujoco.mj_step(model!, data!);
steps++;
}
mujoco.mj_forward(model!, data!);
const res = new mujoco.DoubleBuffer(data!.nefc);
mujoco.mj_mulJacVec(model!, data!, res, data!.qacc);
mujoco.mju_subFrom(res, data!.efc_aref);
const cost = mujoco.DoubleBuffer.FromArray([0]);
mujoco.mj_constraintUpdate(
model!, data!, res.GetView(), cost, /*flg_coneHessian=*/ 1);
expect(cost.GetView()[0]).toBeCloseTo(3355.837);
res.delete();
cost.delete();
} finally {
data!.delete();
model!.delete();
}
});
it('should compute body jacobian', () => {
mujoco.mj_forward(model!, data!);
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const point = [0.1, 0.2, 0.3];
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jac(model!, data!, jacp, jacr, point, bodyId);
expect(norm(jacp.GetView())).toBeGreaterThan(0);
expect(norm(jacr.GetView())).toBeGreaterThan(0);
expect(() => mujoco.mj_jac(model!, data!, null, null, point, bodyId))
.not.toThrow();
} finally {
jacp.delete();
jacr.delete();
}
});
it('should compute body frame jacobian', () => {
mujoco.mj_forward(model!, data!);
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacBody(model!, data!, jacp, jacr, bodyId);
expect(norm(jacp.GetView())).toBeGreaterThan(0);
expect(norm(jacr.GetView())).toBeGreaterThan(0);
expect(() => mujoco.mj_jacBody(model!, data!, null, null, bodyId))
.not.toThrow();
} finally {
jacp.delete();
jacr.delete();
}
});
it('should compute body CoM jacobian', () => {
mujoco.mj_forward(model!, data!);
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacBodyCom(model!, data!, jacp, jacr, bodyId);
expect(norm(jacp.GetView())).toBeGreaterThan(0);
expect(norm(jacr.GetView())).toBeGreaterThan(0);
expect(() => mujoco.mj_jacBodyCom(model!, data!, null, null, bodyId))
.not.toThrow();
} finally {
jacp.delete();
jacr.delete();
}
});
it('should compute geom jacobian', () => {
mujoco.mj_forward(model!, data!);
const geomId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'mybox');
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacGeom(model!, data!, jacp, jacr, geomId);
expect(norm(jacp.GetView())).toBeGreaterThan(0);
expect(norm(jacr.GetView())).toBeGreaterThan(0);
expect(() => mujoco.mj_jacGeom(model!, data!, null, null, geomId))
.not.toThrow();
} finally {
jacp.delete();
jacr.delete();
}
});
it('should compute point-axis jacobian', () => {
mujoco.mj_forward(model!, data!);
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const point = [0.1, 0.2, 0.3];
const axis = [0, 0, 1];
const jacPoint = new mujoco.DoubleBuffer(3 * model!.nv);
const jacAxis = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacPointAxis(
model!, data!, jacPoint, jacAxis, point, axis, bodyId);
expect(norm(jacPoint.GetView())).toBeGreaterThan(0);
expect(norm(jacAxis.GetView())).toBeGreaterThan(0);
expect(
() => mujoco.mj_jacPointAxis(
model!, data!, null, null, point, axis, bodyId))
.not.toThrow();
} finally {
jacPoint.delete();
jacAxis.delete();
}
});
it('should compute jacobian time derivative', () => {
mujoco.mj_forward(model!, data!);
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const point = [0.1, 0.2, 0.3];
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacDot(model!, data!, jacp, jacr, point, bodyId);
expect(jacp.GetView().length).toBe(3 * model!.nv);
expect(jacr.GetView().length).toBe(3 * model!.nv);
expect(() => mujoco.mj_jacDot(model!, data!, null, null, point, bodyId))
.not.toThrow();
} finally {
jacp.delete();
jacr.delete();
}
});
it('should apply external force and torque', () => {
const force = [1, .5, 1];
const torque = [.3, 1, .22];
const point = [0, 0, 0];
const bodyId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_BODY.value, 'mybox');
const qfrcTarget = new mujoco.DoubleBuffer(model!.nv);
try {
mujoco.mj_forward(model!, data!);
mujoco.mj_applyFT(
model!, data!, force, torque, point, bodyId, qfrcTarget);
expect(norm(qfrcTarget.GetView())).toBeGreaterThan(0);
qfrcTarget.GetView().fill(0);
mujoco.mj_applyFT(
model!, data!, null as any, null as any, point, bodyId, qfrcTarget);
expect(norm(qfrcTarget.GetView())).toEqual(0);
} finally {
qfrcTarget.delete();
}
});
it('should compute finite-differenced transition matrices', () => {
const eps = 1e-6;
const flg_centered = 0;
const dim = 2 * model!.nv + model!.na;
const A = new mujoco.DoubleBuffer(dim * dim);
const B = new mujoco.DoubleBuffer(dim * model!.nu);
const C = new mujoco.DoubleBuffer(model!.nsensordata * dim);
const D = new mujoco.DoubleBuffer(model!.nsensordata * model!.nu);
try {
mujoco.mjd_transitionFD(model!, data!, eps, flg_centered, A, B, C, D);
expect(norm(A.GetView())).toBeGreaterThan(0);
expect(norm(B.GetView())).toBeGreaterThan(0);
expect(norm(C.GetView())).toBeGreaterThan(0);
expect(
() => mujoco.mjd_transitionFD(
model!, data!, eps, flg_centered, null, null, null, null))
.not.toThrow();
} finally {
A.delete();
B.delete();
C.delete();
D.delete();
}
});
it('should solve a system of linear equations', () => {
const n = 2;
const mat = [4, 1, 1, 3];
const vec = [1, 2];
const res = new mujoco.DoubleBuffer(n);
const expected = new Float64Array([1 / 11, 7 / 11]);
const matFactor = mujoco.DoubleBuffer.FromArray(mat);
try {
const rank = mujoco.mju_cholFactor(matFactor, 1e-9);
expect(rank).toBe(n);
mujoco.mju_cholSolve(res, matFactor.GetView(), vec);
const result = res.GetView();
expect(result[0]).toBeCloseTo(expected[0]);
expect(result[1]).toBeCloseTo(expected[1]);
} finally {
res.delete();
matFactor.delete();
}
});
it('should update a Cholesky factorization', () => {
const n = 2;
const mat = [4, 1, 1, 3];
const x = [1, 1];
const matFactor = mujoco.DoubleBuffer.FromArray(mat);
const xBuf = mujoco.DoubleBuffer.FromArray(x);
const res = new mujoco.DoubleBuffer(n);
try {
// Factorize original matrix.
mujoco.mju_cholFactor(matFactor, 1e-9);
// Update factorization with x.
const flg_plus = 1;
mujoco.mju_cholUpdate(matFactor, xBuf.GetView(), flg_plus);
// Solve a system with the updated factor to verify.
// A' = A + x*x' = [[5, 2], [2, 4]]
// A' * y = vec => [[5, 2], [2, 4]] * y = [7, 6]
// Solution is y = [1, 1].
const vec = [7, 6];
mujoco.mju_cholSolve(res, matFactor.GetView(), vec);
const result = res.GetView();
const expectedSolution = new Float64Array([1, 1]);
expect(result[0]).toBeCloseTo(expectedSolution[0]);
expect(result[1]).toBeCloseTo(expectedSolution[1]);
} finally {
matFactor.delete();
xBuf.delete();
res.delete();
}
});
it('should multiply a transposed matrix by another matrix', () => {
const r1 = 3, c1 = 2, c2 = 2;
const mat1 = mujoco.DoubleBuffer.FromArray([1, 4, 2, 5, 3, 6]);
const mat2 = mujoco.DoubleBuffer.FromArray([7, 8, 9, 10, 11, 12]);
const res = new mujoco.DoubleBuffer(c1 * c2);
const expected = new Float64Array([58, 64, 139, 154]);
try {
mujoco.mju_mulMatTMat(res, mat1.GetView(), mat2.GetView(), r1, c1, c2);
expectArraysClose(res.GetView(), expected);
} finally {
mat1.delete();
mat2.delete();
res.delete();
}
});
it('should throw an error because of incompatible matrix sizes', () => {
const r1 = 3, c1 = 2, c2 = 2;
const mat1 = mujoco.DoubleBuffer.FromArray([1, 4, 2, 5, 3, 6]);
const mat2 = mujoco.DoubleBuffer.FromArray([7, 8, 9, 10, 11]);
const res = new mujoco.DoubleBuffer(c1 * c2);
try {
expect(
() => mujoco.mju_mulMatTMat(
res, mat1.GetView(), mat2.GetView(), r1, c1, c2))
.toThrowError(
'MuJoCo Error: [mju_mulMatTMat] mat2 must have size 6, got 5');
} finally {
mat1.delete();
mat2.delete();
res.delete();
}
});
it('should convert a dense matrix to sparse and return non-zero count',
() => {
const nr = 2;
const nc = 3;
const mat = [0.0, 1.0, 0.0, 2.0, 0.0, 3.0];
const rownnz = new mujoco.IntBuffer(nr);
const rowadr = new mujoco.IntBuffer(nr);
const colind = new mujoco.IntBuffer(nc);
const res = new mujoco.DoubleBuffer(nc);
try {
const nnz =
mujoco.mju_dense2sparse(res, mat, nr, nc, rownnz, rowadr, colind);
expectArraysEqual(res.GetView(), new Float64Array([1.0, 2.0, 3.0]));
expectArraysEqual(rownnz.GetView(), new Int32Array([1, 2]));
expectArraysEqual(rowadr.GetView(), new Int32Array([0, 1]));
expectArraysEqual(colind.GetView(), new Int32Array([1, 0, 2]));
} finally {
res.delete();
rownnz.delete();
rowadr.delete();
colind.delete();
}
});
it('should convert a sparse matrix to a dense matrix', () => {
const nr = 2;
const nc = 3;
const mat = [1.0, 2.0, 3.0];
const rownnz = [1, 2];
const rowadr = [0, 1];
const colind = [1, 0, 2];
const res = new mujoco.DoubleBuffer(nr * nc);
const expected = new Float64Array([0.0, 1.0, 0.0, 2.0, 0.0, 3.0]);
try {
mujoco.mju_sparse2dense(res, mat, nr, nc, rownnz, rowadr, colind);
expectArraysEqual(res.GetView(), expected);
} finally {
res.delete();
}
});
it('should throw an error when mju_eye is called with a null argument', () => {
expect(() => {
mujoco.mju_eye(null as any);
})
.toThrowError(
'MuJoCo Error: [mju_eye] Invalid argument. Expected a TypedArray or WasmBuffer, got null.');
});
it('should return undefined', () => {
const spec = mujoco.parseXMLString(TEST_XML);
const body = mujoco.mjs_findBody(spec, 'some_name_that_doesnt_exist');
expect(body).toBeUndefined();
body?.delete();
spec?.delete();
});
it('should check constants values', () => {
expect(mujoco.mjNEQDATA).toBe(11);
expect(mujoco.get_mjDISABLESTRING()).toEqual([
'Constraint', 'Equality', 'Frictionloss', 'Limit', 'Contact', 'Spring',
'Damper', 'Gravity', 'Clampctrl', 'Warmstart', 'Filterparent',
'Actuation', 'Refsafe', 'Sensor', 'Midphase', 'Eulerdamp', 'AutoReset',
'NativeCCD', 'Island'
]);
expect(mujoco.get_mjRNDSTRING()).toEqual([
['Shadow', '1', 'S'], ['Wireframe', '0', 'W'], ['Reflection', '1', 'R'],
['Additive', '0', 'L'], ['Skybox', '1', 'K'], ['Fog', '0', 'G'],
['Haze', '1', '/'], ['Depth', '0', ''], ['Segment', '0', ','],
['Id Color', '0', ''], ['Cull Face', '1', '']
]);
expect(mujoco.get_mjFRAMESTRING().length)
.toEqual(mujoco.mjtFrame.mjNFRAME.value);
expect(mujoco.get_mjVISSTRING().length)
.toEqual(mujoco.mjtVisFlag.mjNVISFLAG.value);
expect(mujoco.get_mjVISSTRING()[mujoco.mjtVisFlag.mjVIS_INERTIA.value])
.toEqual(['Inertia', '0', 'I']);
});
it('should create a spec from XML', () => {
const spec = mujoco.parseXMLString(TEST_XML);
try {
expect(spec).toBeDefined();
expect(spec!.modelname).toEqual('test');
} finally {
spec?.delete();
}
});
it('should return the max value', () => {
expect(mujoco.mju_max(10, 2)).toEqual(10);
});
// Corresponds to bindings_test.py:test_mju_rotVecQuat
it('should rotate a vector by a quaternion', () => {
const res = mujoco.DoubleBuffer.FromArray([0, 0, 0]);
const vec = [1, 0, 0];
const angle = 7 * Math.PI / 12;
const quat = [Math.cos(angle), 0, 0, Math.sin(angle)];
const expected = new Float64Array([-0.8660377, -0.5, 0]);
try {
mujoco.mju_rotVecQuat(res, vec, quat);
expectArraysClose(res.GetView(), expected, 4);
} finally {
res.delete();
}
});
it('should get correct geom name', () => {
const spec = mujoco.parseXMLString(TEST_XML);
const geomEl =
mujoco.mjs_findElement(spec, mujoco.mjtObj.mjOBJ_GEOM, 'myplane');
try {
assertExists(geomEl);
const geom = mujoco.mjs_asGeom(geomEl);
assertExists(geom);
const geomName = mujoco.mjs_getName(geom.element);
expect(geomName).toEqual('myplane');
mujoco.mjs_setName(geom.element, 'myplane2');
expect(mujoco.mjs_getName(geom.element)).toEqual('myplane2');
} finally {
spec?.delete();
}
});
it('should override geom userdata', () => {
const spec = mujoco.parseXMLString(TEST_XML);
const geomEl =
mujoco.mjs_findElement(spec, mujoco.mjtObj.mjOBJ_GEOM, 'myplane');
try {
assertExists(geomEl);
const geom = mujoco.mjs_asGeom(geomEl);
assertExists(geom);
geom.userdata.set(0, 10);
expect(geom.userdata.get(0)).toEqual(10);
} finally {
spec.delete();
}
})
it('should override model geom_rgba', () => {
const newValues = new Float32Array([0.1, 0.2, 0.3, 0.4]);
model!.geom_rgba.set(newValues);
const expected = new Float32Array(
[0.1, 0.2, 0.3, 0.4, 0.5, 0.5, 0.5, 1, 0.5, 0.5, 0.5, 1]);
expectArraysClose(model!.geom_rgba, expected);
})
it('should add a scaled vector to another vector', () => {
const res = mujoco.DoubleBuffer.FromArray([1, 2, 3]);
const vec = [4, 5, 6];
const scale = 2;
const expected = new Float64Array([9, 12, 15]);
try {
mujoco.mju_addToScl(res, vec, scale);
expectArraysClose(res.GetView(), expected, 4);
} finally {
res.delete();
}
});
it('should throw an error when mju_addToScl is called with incompatible sizes',
() => {
const res = mujoco.DoubleBuffer.FromArray([1, 2, 3]);
const vec = [4, 5];
const scale = 2;
try {
expect(() => {
mujoco.mju_addToScl(res, vec, scale);
})
.toThrowError(
'MuJoCo Error: [mju_addToScl] res and vec must have equal size, got 3 and 2');
} finally {
res.delete();
}
});
it('should sort an array with insertion sort', () => {
const arr = mujoco.DoubleBuffer.FromArray([5, 2, 8, 1, 9]);
const expected = new Float64Array([1, 2, 5, 8, 9]);
try {
mujoco.mju_insertionSort(arr);
expectArraysEqual(arr.GetView(), expected);
} finally {
arr.delete();
}
});
it('should find the attached spec', () => {
const bXml = `
<mujoco>
<worldbody>
<body name="b" pos="0 0 0.1">
<geom rgba="0 .9 0 1" name="attached_geom_b" type="box" size="0.1 0.1 0.1" mass="0.25"/>
<freejoint name="bfree"/>
</body>
</worldbody>
</mujoco>
`;
const xmlWithAttachedSpec = `
<mujoco>
<asset>
<model name="b" file="b.xml" />
</asset>
<worldbody>
<attach model="b" body="b" prefix="b" />
</worldbody>
</mujoco>
`;
const mainXmlFilename = 'main.xml';
const bXmlFilename = 'b.xml';
writeXMLFile(mainXmlFilename, xmlWithAttachedSpec);
writeXMLFile(bXmlFilename, bXml);
const spec = mujoco.parseXMLString(xmlWithAttachedSpec);
const attachedSpec = mujoco.mjs_findSpec(spec, 'b');
try {
assertExists(attachedSpec);
const geomEl = mujoco.mjs_findElement(
attachedSpec, mujoco.mjtObj.mjOBJ_GEOM, 'attached_geom_b');
assertExists(geomEl);
const geom = mujoco.mjs_asGeom(geomEl);
expect(geom).toBeDefined();
expect(mujoco.mjs_getName(geom!.element)).toEqual('attached_geom_b');
} finally {
attachedSpec?.delete();
spec?.delete();
unlinkXMLFile(mainXmlFilename);
unlinkXMLFile(bXmlFilename);
}
});
// Corresponds to bindings_test.py:test_load_xml_can_handle_name_clash
it('should handle name clashes when loading XML with includes', () => {
const xml1 = `
<mujoco>
<worldbody>
<geom name="plane" type="plane" size="1 1 1"/>
<include file="model_.xml"/>
<include file="model__.xml"/>
</worldbody>
</mujoco>
`;
const xml2 = `<mujoco><geom name="box" type="box" size="1 1 1"/></mujoco>`;
const xml3 = `<mujoco><geom name="ball" type="sphere" size="1"/></mujoco>`;
const modelXmlFilename = 'model.xml';
const model1XmlFilename = 'model_.xml';
const model2XmlFilename = 'model__.xml';
writeXMLFile(modelXmlFilename, xml1);
writeXMLFile(model1XmlFilename, xml2);
writeXMLFile(model2XmlFilename, xml3);
const model = mujoco.MjModel!.mj_loadXML(modelXmlFilename);
try {
expect(model).toBeDefined();
expect(mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'plane'))
.toBe(0);
expect(mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'box'))
.toBe(1);
expect(mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'ball'))
.toBe(2);
} finally {
model?.delete();
unlinkXMLFile(modelXmlFilename);
unlinkXMLFile(model1XmlFilename);
unlinkXMLFile(model2XmlFilename);
}
});
// Corresponds to bindings_test.py:test_can_read_array
it('should read an array from the model', () => {
const expected =
new Float64Array([0, 0, 0, 0, 0, 0.1, 0, 0, 1, 2, 0, 1, 42, 0, 42]);
const bodyPos = new Float64Array(model!.body_pos);
expectArraysEqual(bodyPos, expected);
});
// Corresponds to bindings_test.py:test_can_set_array
it('should set an array from the data', () => {
const value = 0.12345;
data!.qpos.fill(value);
const expected = new Float64Array(data!.qpos.length).fill(value);
expectArraysEqual(data!.qpos, expected);
});
// Corresponds to bindings_test.py:test_array_is_a_view
it('should check that array is a view', () => {
const qposRef = data!.qpos;
const value = 0.789;
data!.qpos.fill(value);
const expected = new Float64Array(data!.qpos.length).fill(value);
expectArraysEqual(qposRef, expected);
});
// Corresponds to bindings_test.py:test_mjmodel_can_read_and_write_opt
it('should read and write MjOption', () => {
expect(model!.opt.timestep).toEqual(0.002);
expectArraysEqual(model!.opt.gravity, new Float64Array([0, 0, -9.81]));
const optRef = model!.opt;
model!.opt.timestep = 0.001;
expect(optRef.timestep).toEqual(0.001);
const gravityRef = optRef.gravity;
model!.opt.gravity[1] = 0.1;
expectArraysEqual(gravityRef, new Float64Array([0, 0.1, -9.81]));
model!.opt.gravity.fill(0.2);
expectArraysEqual(gravityRef, new Float64Array([0.2, 0.2, 0.2]));
});
// Corresponds to bindings_test.py:test_mjmodel_can_read_and_write_stat
it('should read and write MjStat', () => {
expect(model!.stat.meanmass).not.toEqual(0);
const statRef = model!.stat;
model!.stat.meanmass = 1.2;
expect(statRef.meanmass).toEqual(1.2);
});
// Corresponds to bindings_test.py:test_mjmodel_can_read_and_write_vis
it('should read and write MjVis', () => {
expect(model!.vis.quality.shadowsize).toEqual(51);
const visRef = model!.vis;
model!.vis.quality.shadowsize = 100;
expect(visRef.quality.shadowsize).toEqual(100);
});
// Corresponds to bindings_test.py:test_mjmodel_can_access_names_directly
it('should access names directly from the model', () => {
const modelName = new TextDecoder().decode(
model!.names.slice(0, model!.names.indexOf(0)));
expect(modelName).toEqual('test');
const startGeomNameIndex = model!.name_geomadr[0];
const endGeomNameIndex = model!.names.indexOf(0, startGeomNameIndex);
const geomName = new TextDecoder().decode(
model!.names.slice(startGeomNameIndex, endGeomNameIndex));
expect(geomName).toEqual('myplane');
});
// Corresponds to bindings_test.py:test_mjmodel_names_doesnt_copy
it('should not copy names when accessing them multiple times', () => {
const names1 = model!.names;
const names2 = model!.names;
expect(names1).toEqual(names2);
});
// Corresponds to bindings_test.py:test_mjoption_can_make_default
it('should create a default MjOption', () => {
const opt = new mujoco.MjOption();
expect(opt.timestep).toEqual(0.002);
expectArraysEqual(opt.gravity, new Float64Array([0, 0, -9.81]));
});
// Corresponds to bindings_test.py:test_mjoption_can_copy
it('should copy MjOption', () => {
const opt1 = new mujoco.MjOption();
opt1.timestep = 0.001;
opt1.gravity.set([2, 2, 2]);
const opt2 = opt1.copy();
expect(opt2.timestep).toEqual(0.001);
expectArraysEqual(opt2.gravity, new Float64Array([2, 2, 2]));
opt1.timestep = 0.005;
opt1.gravity.set([5, 5, 5]);
expect(opt2.timestep).toEqual(0.001);
expectArraysEqual(opt2.gravity, new Float64Array([2, 2, 2]));
});
// Corresponds to bindings_test.py:test_mjdata_can_read_warning_array
it('should read warning array from MjData', () => {
expect(data!.warning.size()).toEqual(mujoco.mjtWarning.mjNWARNING.value);
data!.qpos[0] = NaN;
mujoco.mj_checkPos(model!, data!);
expect(data!.warning.get(mujoco.mjtWarning.mjWARN_BADQPOS.value)!.number)
.toEqual(1);
});
// Corresponds to bindings_test.py:test_mjcontact_can_copy
it('should copy MjContact', () => {
mujoco.mj_forward(model!, data!!);
const contacts: MjContactVec = data!.contact;
const originalContact = contacts.get(0)!;
const originalPos = new Float64Array(originalContact.pos);
const copiedContact = originalContact.copy();
copiedContact.delete();
expectArraysClose(originalContact.pos, originalPos);
originalContact.delete();
});
// Corresponds to bindings_test.py:test_mj_step
it('should step the simulation forward', () => {
const displacement = 0.55;
data!.qpos[2] += displacement;
mujoco.mj_forward(model!, data!);
const gravity = -model!.opt.gravity[2];
const expectedContactTime = Math.sqrt(2 * displacement / gravity);
model!.opt.timestep = 2 ** -9;
expect(data!.time).toEqual(0);
while (data!.time < expectedContactTime) {
expect(data!.ncon).toEqual(0);
expect(data!.efc_type.length).toEqual(0);
const prevTime = data!.time;
mujoco.mj_step(model!, data!);
expect(data!.time).toEqual(prevTime + model!.opt.timestep);
}
mujoco.mj_forward(model!, data!);
const contact = data!.contact;
expect(data!.ncon).toEqual(4);
expect(data!.efc_type.length).toEqual(16);
expectArraysClose(
contact.get(0)!.pos.slice(0, 2), new Float64Array([-0.1, -0.1]));
expectArraysClose(
contact.get(1)!.pos.slice(0, 2), new Float64Array([0.1, -0.1]));
expectArraysClose(
contact.get(2)!.pos.slice(0, 2), new Float64Array([-0.1, 0.1]));
expectArraysClose(
contact.get(3)!.pos.slice(0, 2), new Float64Array([0.1, 0.1]));
mujoco.mj_resetData(model!, data!);
expect(data!.ncon).toEqual(0);
expect(data!.efc_type.length).toEqual(0);
});
// Corresponds to bindings_test.py:test_mj_struct_equality_array
it('should check MjContact equality with array', () => {
const contact1 = new mujoco.MjContact();
const contact2 = new mujoco.MjContact();
try {
contact1.H[3] = 1;
expect(contact1.H).not.toEqual(contact2.H);
contact2.H[3] = 1;
expect(contact1).toEqual(contact2);
} finally {
contact1.delete();
contact2.delete();
}
});
// Corresponds to bindings_test.py:test_mj_struct_list_equality
it('should check MjContactVec equality', () => {
const tempXmlFilename2 = '/tmp/model2.xml';
writeXMLFile(tempXmlFilename2, TEST_XML);
const model2 = mujoco.MjModel!.mj_loadXML(tempXmlFilename2);
const data2 = new mujoco.MjData(model2);
try {
mujoco.mj_forward(model!, data!);
expect(data!.ncon).toEqual(4);
mujoco.mj_forward(model2, data2);
expect(data2.ncon).toEqual(4);
expect(data2.contact).toEqual(data!.contact);
data!.qpos[3] = Math.cos(Math.PI / 8);
data!.qpos[4] = Math.sin(Math.PI / 8);
data!.qpos[5] = 0;
data!.qpos[6] = 0;
data!.qpos[2] = (Math.sqrt(2) - 1) * 0.1 - 1e-6;
mujoco.mj_forward(model!, data!);
expect(data!.ncon).toEqual(2);
expect(data2.contact.size()).not.toEqual(data!.contact.size());
expect(data!.contact).not.toBe(data!.warning);
} finally {
model2.delete();
data2.delete();
unlinkXMLFile(tempXmlFilename2);
}
});
// Corresponds to bindings_test.py:test_getsetstate
it('should get and set the state', () => {
mujoco.mj_step(model!, data!);
const invalidSig = 2 ** mujoco.mjtState.mjNSTATE.value;
expect(() => {
mujoco.mj_stateSize(model!, invalidSig);
})
.toThrowError(
'MuJoCo Error: mj_stateSize: invalid state signature 16384 >= 2^mjNSTATE');
const sig = mujoco.mjtState.mjSTATE_INTEGRATION.value;
const size = mujoco.mj_stateSize(model!, sig);
const stateBadSize = mujoco.DoubleBuffer.FromArray([size]);
expect(() => {
mujoco.mj_getState(model!, data!, stateBadSize, sig);
})
.toThrowError(
'MuJoCo Error: [mj_getState] state must have size 81, got 1');
const state0 = new mujoco.DoubleBuffer(size);
mujoco.mj_getState(model!, data!, state0, sig);
mujoco.mj_step(model!, data!);
const state1a = mujoco.DoubleBuffer.FromArray(new Array(size).fill(1));
mujoco.mj_getState(model!, data!, state1a, sig);
mujoco.mj_setState(model!, data!, state0.GetView(), sig);
mujoco.mj_step(model!, data!);
const state1b = mujoco.DoubleBuffer.FromArray(new Array(size).fill(2));
mujoco.mj_getState(model!, data!, state1b, sig);
expectArraysEqual(state1a.GetView(), state1b.GetView());
});
// Corresponds to bindings_test.py:test_mj_setKeyframe
it('should set and reset a keyframe', () => {
mujoco.mj_step(model!, data!);
const invalidKey = 2;
expect(() => {
mujoco.mj_setKeyframe(model!, data!, invalidKey);
})
.toThrowError(
'MuJoCo Error: mj_setKeyframe: index must be smaller than 2 (keyframes allocated in model)');
const validKey = 1;
const time = data!.time;
const qpos = new Float64Array(data!.qpos);
const qvel = new Float64Array(data!.qvel);
const act = new Float64Array(data!.act);
mujoco.mj_setKeyframe(model!, data!, validKey);
mujoco.mj_step(model!, data!);
expect(time).not.toEqual(data!.time);
mujoco.mj_resetDataKeyframe(model!, data!, validKey);
expect(time).toEqual(data!.time);
expectArraysEqual(qpos, data!.qpos);
expectArraysEqual(qvel, data!.qvel);
expectArraysEqual(act, data!.act);
});
// Corresponds to bindings_test.py:test_mj_angmomMat
it('should compute angular momentum matrix', () => {
data!.qvel.fill(1);
mujoco.mj_forward(model!, data!);
mujoco.mj_subtreeVel(model!, data!);
const mat = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_angmomMat(model!, data!, mat, 0);
const qvel = new Float64Array(data!.qvel);
const subtreeAngmom = new Float64Array(data!.subtree_angmom.slice(0, 3));
const matView = mat.GetView();
const result = new Float64Array(3).fill(0);
for (let i = 0; i < 3; i++) {
for (let j = 0; j < model!.nv; j++) {
result[i] += matView[i * model!.nv + j] * qvel[j];
}
}
expectArraysClose(result, subtreeAngmom);
} finally {
mat.delete();
}
});
// Corresponds to bindings_test.py:test_mj_jacSite
it('should compute site jacobian', () => {
mujoco.mj_forward(model!, data!);
const siteId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_SITE.value, 'mysite');
const jacp = new mujoco.DoubleBuffer(3 * model!.nv);
const jacr = new mujoco.DoubleBuffer(3 * model!.nv);
try {
mujoco.mj_jacSite(model!, data!, jacp, null, siteId);
const expectedJacp = new Float64Array(3 * model!.nv).fill(0);
expectedJacp[6] = -1;
expectArraysClose(jacp.GetView(), expectedJacp);
mujoco.mj_jacSite(model!, data!, null, jacr, siteId);
const expectedJacr = new Float64Array(3 * model!.nv).fill(0);
expectedJacr[1 * model!.nv + 6] = 1;
expectArraysClose(jacr.GetView(), expectedJacr, 2);
jacp.GetView().fill(0);
jacr.GetView().fill(0);
mujoco.mj_jacSite(model!, data!, jacp, jacr, siteId);
expectArraysClose(jacp.GetView(), expectedJacp, 2);
expectArraysClose(jacr.GetView(), expectedJacr, 2);
const badJacp = new mujoco.DoubleBuffer(3 * 6);
try {
expect(() => {
mujoco.mj_jacSite(model!, data!, badJacp, null, siteId);
})
.toThrowError(
'MuJoCo Error: [mj_jacSite] jacp must have size 30, got 18');
} finally {
badJacp.delete();
}
const badJacr = new mujoco.DoubleBuffer(4 * 7);
try {
expect(() => {
mujoco.mj_jacSite(model!, data!, null, badJacr, siteId);
})
.toThrowError(
'MuJoCo Error: [mj_jacSite] jacr must have size 30, got 28');
} finally {
badJacr.delete();
}
} finally {
jacp.delete();
jacr.delete();
}
});
// Corresponds to bindings_test.py:test_can_initialize_mjv_structs
it('should initialize mjv structs', () => {
expect(new mujoco.MjvScene()).toBeDefined();
expect(new mujoco.MjvCamera()).toBeDefined();
expect(new mujoco.MjvGLCamera()).toBeDefined();
expect(new mujoco.MjvGeom()).toBeDefined();
expect(new mujoco.MjvLight()).toBeDefined();
expect(new mujoco.MjvOption()).toBeDefined();
expect(new mujoco.MjvFigure()).toBeDefined();
expect(new mujoco.MjvScene(model, 100)).toBeDefined();
});
// Corresponds to bindings_test.py:test_mjv_camera
it('should handle MjvCamera correctly', () => {
const camera = new mujoco.MjvCamera();
camera.type = mujoco.mjtCamera.mjCAMERA_TRACKING.value;
camera.fixedcamid = 2 ** 31 - 1;
expect(camera.fixedcamid).toEqual(2 ** 31 - 1);
});
// Corresponds to bindings_test.py:test_mjv_scene
it('should handle MjvScene correctly', () => {
const scene = new mujoco.MjvScene(model, 100);
expect(scene.ngeom).toEqual(0);
expect(scene.maxgeom).toEqual(100);
expect(scene.geoms.size()).toEqual(0);
mujoco.mj_forward(model!, data!);
mujoco.mjv_updateScene(
model!, data!, new mujoco.MjvOption(), new mujoco.MjvPerturb(),
new mujoco.MjvCamera(), mujoco.mjtCatBit.mjCAT_ALL.value, scene);
expect(scene.geoms.size()).toEqual(scene.ngeom);
expect(scene.ngeom).toBeGreaterThan(0);
});
// Corresponds to bindings_test.py:test_mjv_scene_without_model
it('should initialize MjvScene without a model', () => {
const scene = new mujoco.MjvScene();
expect(scene.scale).toEqual(1.0);
expect(scene.maxgeom).toEqual(0);
});
// Corresponds to bindings_test.py:test_inverse_fd_none
it('should compute inverse dynamics derivatives with null outputs', () => {
const eps = 1e-6;
const flg_centered = 0;
expect(
() => mujoco.mjd_inverseFD(
model!, data!, eps, flg_centered, null, null, null, null, null,
null, null))
.not.toThrow();
});
// Corresponds to bindings_test.py:test_inverse_fd
it('should compute inverse dynamics derivatives', () => {
const eps = 1e-6;
const flg_centered = 0;
const nv = model!.nv;
const nsensordata = model!.nsensordata;
const nM = model!.nM;
const dfDq = new mujoco.DoubleBuffer(nv * nv);
const dfDv = new mujoco.DoubleBuffer(nv * nv);
const dfDa = new mujoco.DoubleBuffer(nv * nv);
const dsDq = new mujoco.DoubleBuffer(nv * nsensordata);
const dsDv = new mujoco.DoubleBuffer(nv * nsensordata);
const dsDa = new mujoco.DoubleBuffer(nv * nsensordata);
const dmDq = new mujoco.DoubleBuffer(nv * nM);
try {
mujoco.mjd_inverseFD(
model!, data!, eps, flg_centered, dfDq, dfDv, dfDa, dsDq, dsDv, dsDa,
dmDq);
expect(norm(dfDq.GetView())).toBeGreaterThan(eps);
expect(norm(dfDv.GetView())).toBeGreaterThan(eps);
expect(norm(dfDa.GetView())).toBeGreaterThan(eps);
expect(norm(dsDq.GetView())).toBeGreaterThan(eps);
expect(norm(dsDv.GetView())).toBeGreaterThan(eps);
expect(norm(dsDa.GetView())).toBeGreaterThan(eps);
} finally {
dfDq.delete();
dfDv.delete();
dfDa.delete();
dsDq.delete();
dsDv.delete();
dsDa.delete();
dmDq.delete();
}
});
// Corresponds to bindings_test.py:test_geom_distance
it('should compute geom distance', () => {
mujoco.mj_forward(model!, data!);
const fromto = new mujoco.DoubleBuffer(6);
try {
const dist = mujoco.mj_geomDistance(model!, data!, 0, 2, 200, fromto);
expect(dist).toEqual(41.9);
expectArraysClose(
fromto.GetView(),
new Float64Array([42.0, 0.0, 0.0, 42.0, 0.0, 41.9]));
} finally {
fromto.delete();
}
});
// Corresponds to bindings_test.py:test_mjd_sub_quat
it('should compute sub quaternion derivatives', () => {
const quat1 = [0.2, 0.3, 0.3, 0.4];
const quat2 = [0.1, 0.2, 0.4, 0.5];
const d1 = new mujoco.DoubleBuffer(9);
const d2 = new mujoco.DoubleBuffer(9);
const d3 = new mujoco.DoubleBuffer(9);
const d4 = new mujoco.DoubleBuffer(9);
try {
mujoco.mjd_subQuat(quat1, quat2, d1, d2);
mujoco.mjd_subQuat(quat1, quat2, null, d3);
mujoco.mjd_subQuat(quat1, quat2, d4, null);
expectArraysEqual(d2.GetView(), d3.GetView());
expectArraysEqual(d1.GetView(), d4.GetView());
} finally {
d1.delete();
d2.delete();
d3.delete();
d4.delete();
}
});
// Corresponds to bindings_test.py:test_mjd_quat_integrate
it('should compute quaternion derivatives for integration', () => {
const scale = 0.1;
const vel = [0.2, 0.3, 0.3];
const dQuat = new mujoco.DoubleBuffer(9);
const dVel = new mujoco.DoubleBuffer(9);
const dH = new mujoco.DoubleBuffer(3);
try {
mujoco.mjd_quatIntegrate(vel, scale, dQuat, dVel, dH);
expect(norm(dQuat.GetView())).toBeGreaterThan(0);
expect(norm(dVel.GetView())).toBeGreaterThan(0);
expect(norm(dH.GetView())).toBeGreaterThan(0);
} finally {
dQuat.delete();
dVel.delete();
dH.delete();
}
});
// Corresponds to bindings_test.py:test_banded
it('should handle banded matrices', () => {
const nTotal = 4;
const nBand = 1;
const nDense = 1;
const dense = [
1.0,
0,
0,
0.1,
0,
2.0,
0,
0.2,
0,
0,
3.0,
0.3,
0.1,
0.2,
0.3,
4.0,
];
const band =
new mujoco.DoubleBuffer(nBand * (nTotal - nDense) + nDense * nTotal);
const vec = mujoco.DoubleBuffer.FromArray([2.0, 2.0, 3.0, 4.0]);
const res = new mujoco.DoubleBuffer(4);
try {
mujoco.mju_dense2Band(band, dense, nTotal, nBand, nDense);
for (let i = 0; i < 4; i++) {
const index = mujoco.mju_bandDiag(i, nTotal, nBand, nDense);
expect(band.GetView()[index]).toEqual(i + 1);
}
const dense2 = new mujoco.DoubleBuffer(nTotal * nTotal);
const flgSym = 1;
mujoco.mju_band2Dense(
dense2, band.GetView(), nTotal, nBand, nDense, flgSym);
expectArraysEqual(new Float64Array(dense), dense2.GetView());
const nVec = 1;
mujoco.mju_bandMulMatVec(
res, band.GetView(), vec.GetView(), nTotal, nBand, nDense, nVec,
flgSym);
const expected = new Float64Array([2.4, 4.8, 10.2, 17.5]);
expectArraysClose(res.GetView(), expected);
const diagAdd = 0;
const diagMul = 0;
mujoco.mju_cholFactorBand(band, nTotal, nBand, nDense, diagAdd, diagMul);
mujoco.mju_cholSolveBand(
res, band.GetView(), vec.GetView(), nTotal, nBand, nDense);
const expectedSolved = new Float64Array([1.9111, 0.9111, 0.9111, 0.8333]);
expectArraysClose(res.GetView(), expectedSolved);
} finally {
band.delete();
vec.delete();
res.delete();
}
});
// Corresponds to bindings_test.py:test_mju_box_qp
it('should handle box QP solver', () => {
const n = 5;
const res = new mujoco.DoubleBuffer(n);
const r = new mujoco.DoubleBuffer(n * (n + 7));
const index = new mujoco.IntBuffer(n);
const h = new mujoco.DoubleBuffer(n * n);
const g = mujoco.DoubleBuffer.FromArray(new Array(n).fill(1));
const lower = new Array(n).fill(-1);
const upper = new Array(n).fill(1);
try {
for (let i = 0; i < n; i++) {
h.GetView()[i * (n + 1)] = 1;
}
const rank = mujoco.mju_boxQP(
res, r, index, h.GetView(), g.GetView(), lower, upper);
expect(rank).toBeGreaterThan(-1);
} finally {
res.delete();
r.delete();
index.delete();
h.delete();
g.delete();
}
});
// Corresponds to bindings_test.py:test_mju_fill
it('should fill an array with a value', () => {
const res = new mujoco.DoubleBuffer(3);
try {
mujoco.mju_fill(res, 1.5);
expectArraysEqual(res.GetView(), new Float64Array([1.5, 1.5, 1.5]));
} finally {
res.delete();
}
});
// Corresponds to bindings_test.py:test_mju_eye
it('should create an identity matrix', () => {
const eye3 = new mujoco.DoubleBuffer(3 * 3);
try {
mujoco.mju_eye(eye3);
const expected = new Float64Array([
1,
0,
0,
0,
1,
0,
0,
0,
1,
]);
expectArraysEqual(eye3.GetView(), expected);
} finally {
eye3.delete();
}
});
// Corresponds to bindings_test.py:test_mju_symmetrize
it('should symmetrize a matrix', () => {
const mat = [
0, 0.066, 0.13, 0.2, 0.26, 0.33, 0.4, 0.46, 0.53, 0.6, 0.66, 0.73, 0.8,
0.86, 0.93, 1
];
const res = new mujoco.DoubleBuffer(16);
try {
mujoco.mju_symmetrize(res, mat, 4);
const expected = new Float64Array([
0, 0.163, 0.33, 0.5, 0.163, 0.33, 0.5, 0.66, 0.33, 0.5, 0.66, 0.83, 0.5,
0.66, 0.8, 1
]);
expectArraysClose(res.GetView(), expected);
} finally {
res.delete();
}
});
// Corresponds to bindings_test.py:test_mju_clip
it('should clip a value', () => {
expect(mujoco.mju_clip(1.5, 1.0, 2.0)).toEqual(1.5);
expect(mujoco.mju_clip(1.5, 2.0, 3.0)).toEqual(2.0);
expect(mujoco.mju_clip(1.5, 0.0, 1.0)).toEqual(1.0);
});
// Corresponds to bindings_test.py:test_mju_mul_vec_mat_vec
it('should multiply a vector by a matrix and a vector', () => {
const vec1 = [1.0, 2.0, 3.0];
const vec2 = [3.0, 2.0, 1.0];
const mat = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
expect(mujoco.mju_mulVecMatVec(vec1, mat, vec2)).toEqual(204.0);
});
// Corresponds to bindings_test.py:test_mju_dense_to_sparse
it('should convert a dense matrix to a sparse matrix', () => {
const mat = [0.0, 1.0, 0.0, 2.0, 0.0, 3.0];
const res = new mujoco.DoubleBuffer(3);
const rowNnz = new mujoco.IntBuffer(2);
const rowAdr = new mujoco.IntBuffer(2);
const colInd = new mujoco.IntBuffer(3);
try {
const status =
mujoco.mju_dense2sparse(res, mat, 2, 3, rowNnz, rowAdr, colInd);
expect(status).toEqual(0);
expectArraysEqual(res.GetView(), new Float64Array([1.0, 2.0, 3.0]));
expectArraysEqual(rowNnz.GetView(), new Int32Array([1, 2]));
expectArraysEqual(rowAdr.GetView(), new Int32Array([0, 1]));
expectArraysEqual(colInd.GetView(), new Int32Array([1, 0, 2]));
} finally {
rowNnz.delete();
rowAdr.delete();
colInd.delete();
}
});
// Corresponds to bindings_test.py:test_mju_sparse_to_dense
it('should convert a sparse matrix to a dense matrix', () => {
const mat = [1.0, 2.0, 3.0];
const expected = new Float64Array([0.0, 1.0, 0.0, 2.0, 0.0, 3.0]);
const rowNnz = [1, 2];
const rowAdr = [0, 1];
const colInd = [1, 0, 2];
const res = new mujoco.DoubleBuffer(6);
try {
mujoco.mju_sparse2dense(res, mat, 2, 3, rowNnz, rowAdr, colInd);
expectArraysEqual(res.GetView(), expected);
} finally {
res.delete();
}
});
// Corresponds to bindings_test.py:test_mju_euler_to_quat
it('should convert euler to quaternion', () => {
const quat = new mujoco.DoubleBuffer(4);
const euler = [0, Math.PI / 2, 0];
const seq = 'xyz';
try {
mujoco.mju_euler2Quat(quat, euler, seq);
const expectedQuat = [Math.sqrt(0.5), 0, Math.sqrt(0.5), 0.0];
expectArraysClose(quat.GetView(), new Float64Array(expectedQuat));
expect(() => {
mujoco.mju_euler2Quat(quat, euler, 'xy');
})
.toThrowError(
'MuJoCo Error: mju_euler2Quat: seq must contain exactly 3 characters');
expect(() => {
mujoco.mju_euler2Quat(quat, euler, 'xyzy');
})
.toThrowError(
'MuJoCo Error: mju_euler2Quat: seq must contain exactly 3 characters');
expect(() => {
mujoco.mju_euler2Quat(quat, euler, 'xYp');
})
.toThrowError(
`MuJoCo Error: mju_euler2Quat: seq[2] is 'p', should be one of x, y, z, X, Y, Z`);
} finally {
quat.delete();
}
});
// Corresponds to bindings_test.py:test_texture_size
it('should load a texture from a model', () => {
const texFilename = 'tex.png';
writeXMLFile(texFilename, 'tex');
const tempXmlFilename = '/tmp/with_texture.xml';
const TEST_XML_TEXTURE = `
<mujoco>
<asset>
<texture name="tex" type="2d" builtin="checker" rgb1=".2 .3 .4" rgb2=".1 0.15 0.2"
width="512" height="512" mark="cross" markrgb=".8 .8 .8"/>
<material name="mat" reflectance="0.3" texture="tex" texrepeat="1 1" texuniform="true"/>
</asset>
<worldbody>
<geom type="plane" size="1 1 1" material="mat"/>
</worldbody>
</mujoco>
`;
writeXMLFile(tempXmlFilename, TEST_XML_TEXTURE);
const model = mujoco.MjModel!.mj_loadXML(tempXmlFilename);
try {
expect(model).toBeDefined();
expect(model!.tex_height).toEqual(new Int32Array([512]));
expect(model!.tex_width).toEqual(new Int32Array([512]));
} finally {
model?.delete();
unlinkXMLFile(texFilename);
unlinkXMLFile(tempXmlFilename);
}
});
it('should create distinct MjModel instances and copy correctly', () => {
const model1 = model!;
const model2 = new mujoco.MjModel(model1);
try {
assertExists(model1);
assertExists(model2);
expect(model1).not.toBe(model2);
expect(model1.opt.timestep).toEqual(model2.opt.timestep);
expect(model1.stat.meanmass).toEqual(model2.stat.meanmass);
model1.opt.timestep = 0.123;
expect(model1.opt.timestep).toEqual(0.123);
expect(model2.opt.timestep).not.toEqual(model1.opt.timestep);
expect(model2.opt.timestep).toEqual(0.002);
} finally {
model2.delete();
}
});
it('should create distinct MjData instances and copy correctly', () => {
const data1 = new mujoco.MjData(model!);
const data2 = new mujoco.MjData(model!, data1);
try {
assertExists(data1);
assertExists(data2);
expect(data1).not.toBe(data2);
expectArraysEqual(data1.qpos, data2.qpos);
expectArraysEqual(data1.qvel, data2.qvel);
data1.qpos[0] = 1.0;
expect(data1.qpos[0]).toEqual(1.0);
expect(data2.qpos[0]).not.toEqual(data1.qpos[0]);
} finally {
data1.delete();
data2.delete();
}
});
// Corresponds to specs_test.py:test_address
it('should create distinct MjSpec instances and copy correctly', () => {
const spec1 = mujoco.parseXMLString(TEST_XML);
const spec2 = new mujoco.MjSpec(spec1);
try {
assertExists(spec1);
assertExists(spec2);
expect(spec1).not.toBe(spec2);
expect(spec1.modelname).toEqual(spec2.modelname);
expect(spec1.option.timestep).toEqual(spec2.option.timestep);
expect(spec1.visual.quality.shadowsize)
.toEqual(spec2.visual.quality.shadowsize);
expect(spec1.stat.meanmass).toEqual(spec2.stat.meanmass);
spec1.modelname = 'modified';
expect(spec2.modelname).not.toEqual(spec1.modelname);
expect(spec2.modelname).toEqual('test');
} finally {
spec1?.delete();
spec2?.delete();
}
});
// Corresponds to partial of user_api_test.cc:TEST_F(PluginTest, AttachPlugin)
it('should correctly copy MjSpec instances when attaching plugins', () => {
const xmlPlugin1 = `
<mujoco model="MuJoCo Model">
<worldbody>
<body name="body"/>
</worldbody>
</mujoco>`;
const spec1 = mujoco.parseXMLString(xmlPlugin1);
const spec2 = new mujoco.MjSpec(spec1);
const spec3 = new mujoco.MjSpec(spec1);
try {
assertExists(spec1);
assertExists(spec2);
assertExists(spec3);
spec2.modelname = 'first_copy';
spec3.modelname = 'second_copy';
expect(spec1.modelname).toEqual('MuJoCo Model');
expect(spec2.modelname).toEqual('first_copy');
expect(spec3.modelname).toEqual('second_copy');
} finally {
spec1?.delete();
spec2?.delete();
spec3?.delete();
}
});
it('should save the model to an XML file', () => {
const tempXmlFilename = '/tmp/saved_model.xml';
const xml = `<mujoco model="MuJoCo Model">
<compiler angle="radian"/>
<asset>
<texture type="2d" colorspace="auto" name="tex" builtin="checker" mark="cross" rgb1="0.2 0.3 0.4" rgb2="0.1 0.15 0.2" markrgb="0.8 0.8 0.8" width="512" height="512"/>
<material name="mat" texture="tex" texuniform="true" reflectance="0.3"/>
</asset>
<worldbody>
<geom size="1 1 1" type="plane" material="mat"/>
</worldbody>
</mujoco>`;
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel!.mj_loadXML(tempXmlFilename);
try {
mujoco.mj_saveLastXML(tempXmlFilename, model!);
const savedXmlContent =
(mujoco as any).FS.readFile(tempXmlFilename, {encoding: 'utf8'});
// Remove whitespaces from the saved XML content to avoid flakiness.
expect(savedXmlContent.replace(/\s/g, ''))
.toEqual(xml.replace(/\s/g, ''));
} finally {
unlinkXMLFile(tempXmlFilename);
}
});
it('can call mj_setLengthRange with actuators', () => {
const tempXmlFilename = '/tmp/actuator_model.xml';
const actuatorXml = `<mujoco model="actuator_test">
<worldbody>
<body>
<inertial pos="0 0 0" mass="1" diaginertia="1 1 1"/>
<joint name="hinge1" type="hinge" axis="0 1 0"/>
</body>
</worldbody>
<actuator>
<position name="myactuator" joint="hinge1"/>
</actuator>
</mujoco>`;
writeXMLFile(tempXmlFilename, actuatorXml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
assertExists(model);
const data = new mujoco.MjData(model);
assertExists(data);
const opt = new mujoco.MjLROpt();
try {
const result = mujoco.mj_setLengthRange(
model,
data,
/* index= */ 0,
opt,
);
expect(result).toBe(1);
} finally {
opt.delete();
model.delete();
data.delete();
unlinkXMLFile(tempXmlFilename);
}
});
it('should compile a spec from XML string with no assets', () => {
let spec = null;
let model = null;
try {
spec = mujoco.parseXMLString(TEST_XML);
expect(spec).not.toBeNull();
model = mujoco.mj_compile(spec);
expect(model).not.toBeNull();
expect(model.nq).toBeGreaterThan(0);
const jointId =
mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_JOINT.value, 'myhinge');
expect(jointId).toBeGreaterThanOrEqual(0);
} finally {
if (spec) {
spec.delete();
}
if (model) {
model.delete();
}
}
});
it('should compile a spec from XML with .obj asset', () => {
const xml = `
<mujoco>
<asset>
<mesh file="cube.obj"/>
</asset>
<worldbody>
<geom type="mesh" mesh="cube"/>
</worldbody>
</mujoco>`;
const cube1 = `
v -1 -1 1
v 1 -1 1
v -1 1 1
v 1 1 1
v -1 1 -1
v 1 1 -1
v -1 -1 -1
v 1 -1 -1`;
let spec: MjSpec|null = null;
let model: MjModel|null = null;
let vfs: MjVFS|null = null;
try {
spec = mujoco.parseXMLString(xml);
assertExists(spec);
vfs = new mujoco.MjVFS();
vfs.addBuffer('cube.obj', new TextEncoder().encode(cube1));
assertExists(vfs);
model = mujoco.mj_compile(spec, vfs);
assertExists(model);
expect(model.nmesh).toBe(1);
const meshId =
mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_MESH.value, 'cube');
expect(meshId).toBeGreaterThanOrEqual(0);
} finally {
spec?.delete();
vfs?.delete();
model?.delete();
}
});
it('should compile a spec from XML with 10 meshes and 10 textures', () => {
const assetsCount = 10;
let xml = `<mujoco>
<asset>`;
const cube1 = `
v -1 -1 1
v 1 -1 1
v -1 1 1
v 1 1 1
v -1 1 -1
v 1 1 -1
v -1 -1 -1
v 1 -1 -1`;
const dummyTex = 'dummy texture data';
for (let i = 0; i < assetsCount; i++) {
xml += `<mesh name="cube${i}" file="cube${i}.obj"/>`;
xml += `<texture name="tex${
i}" type="2d" builtin="checker" width="16" height="16"/>`;
}
xml += `</asset><worldbody>`;
for (let i = 0; i < assetsCount; i++) {
xml += `<geom type="mesh" mesh="cube${i}"/>`;
}
xml += `</worldbody></mujoco>`;
let spec: MjSpec|null = null;
let model: MjModel|null = null;
let vfs: MjVFS|null = null;
try {
spec = mujoco.parseXMLString(xml);
assertExists(spec);
vfs = new mujoco.MjVFS();
assertExists(vfs);
for (let i = 0; i < assetsCount; i++) {
vfs.addBuffer(`cube${i}.obj`, new TextEncoder().encode(cube1));
vfs.addBuffer(`tex${i}.txt`, new TextEncoder().encode(dummyTex));
}
model = mujoco.mj_compile(spec, vfs);
assertExists(model);
expect(model.nmesh).toBe(assetsCount);
expect(model.ntex).toBe(assetsCount);
for (let i = 0; i < assetsCount; i++) {
const meshId = mujoco.mj_name2id(
model, mujoco.mjtObj.mjOBJ_MESH.value, `cube${i}`);
expect(meshId).toBe(i);
const tex = model.tex(`tex${i}`);
expect(tex).toBeDefined();
expect(tex!.name).toBe(`tex${i}`);
}
} finally {
spec?.delete();
vfs?.delete();
model?.delete();
}
});
describe('MjModel named access', () => {
// Corresponds to
// bindings_test.py:test_named_indexing_invalid_names_in_model
it('should throw an error for invalid geom names in model', () => {
expect(() => {
model!.geom('badgeom');
})
.toThrowError(
`MuJoCo Error: Invalid name 'badgeom' for geom. Valid names: ['mocap-sphere', 'mybox', 'myplane']`);
});
// Corresponds to
// bindings_test.py:test_named_indexing_invalid_index_in_model
it('should throw an error for invalid geom indices in model', () => {
const numGeoms = model!.ngeom;
expect(() => {
model!.geom(numGeoms);
})
.toThrowError(
`MuJoCo Error: Invalid index 3 for geom. Valid indices from 0 to 2`);
expect(() => {
model!.geom(-1);
})
.toThrowError(
`MuJoCo Error: Invalid index -1 for geom. Valid indices from 0 to 2`);
});
// Corresponds to bindings_test.py:test_named_indexing_geom_size
it('should correctly access geom size using named indexing', () => {
const boxId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'mybox');
assertExists(boxId);
// Check that named indexing returns the same object as id indexing.
expect(model!.geom('mybox')).toEqual(model!.geom(boxId));
expect(model!.geom('mybox')!.size).toEqual(model!.geom(boxId)!.size);
expect(model!.geom('mybox')!.size.length).toEqual(3);
// Test that the indexer is returning a view into the underlying struct.
const sizeFromIndexer = model!.geom('mybox')!.size;
const originalGeomSize = new Float64Array(model!.geom_size);
model!.geom_size.set([7, 11, 13], boxId * 3);
expectArraysEqual(sizeFromIndexer, new Float64Array([7, 11, 13]));
model!.geom('mybox')!.size.set([5, 3, 2]);
expectArraysEqual(
model!.geom_size.slice(boxId * 3, boxId * 3 + 3),
new Float64Array([5, 3, 2]));
});
// Corresponds to bindings_test.py:test_named_indexing_geom_quat
it('should correctly access geom quat using named indexing', () => {
const boxId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_GEOM.value, 'mybox');
assertExists(boxId);
// Check that named indexing returns the same object as id indexing.
expect(model!.geom('mybox')).toEqual(model!.geom(boxId));
expect(model!.geom('mybox')!.quat).toEqual(model!.geom(boxId)!.quat);
expect(model!.geom('mybox')!.quat.length).toEqual(4);
// Test that the indexer is returning a view into the underlying struct.
const quatFromIndexer = model!.geom('mybox')!.quat;
model!.geom_quat.set([5, 10, 15, 20], boxId * 4);
expectArraysEqual(quatFromIndexer, new Float64Array([5, 10, 15, 20]));
model!.geom('mybox')!.quat.set([12, 9, 6, 3]);
expectArraysEqual(
model!.geom_quat.slice(boxId * 4, boxId * 4 + 4),
new Float64Array([12, 9, 6, 3]));
});
it('should support named access for Joints', () => {
const xml = `<mujoco model="Box falling">
<option viscosity="1"/>
<worldbody>
<light diffuse=".5 .5 .5" pos="0 0 3" dir="0 0 -1"/>
<geom name="MyFloor" type="plane" size="1 1 0.1" rgba=".9 0 0 1" user="5 4 3 2 1"/>
<geom name="MyWall" type="plane" size="0.1 1 0.1" rgba="0 1 0 1" user="5 4 3"/>
<body pos="0 0 1" name="MyBox">
<joint type="free" name="root"/>
<geom name="MyBoxGeom" type="box" size=".1 .2 .3" rgba="0 .9 0 1"/>
<body pos=".1 0 0" name="MyHingeBody">
<joint frictionloss="0.4" type="hinge" name="hinge" axis="0 1 0"/>
<geom type="capsule" size=".05 .05" rgba="0 0 .9 1"/>
</body>
</body>
</worldbody>
</mujoco>`;
const tempXmlFilename = '/tmp/jnt.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
try {
assertExists(model);
const j0 = model.jnt('root');
expect(j0.id).toBe(0);
expect(j0.name).toBe('root');
expect(j0.type).toBe(mujoco.mjtJoint.mjJNT_FREE.value);
expect(j0.qposadr).toBe(0);
expect(j0.dofadr).toBe(0);
expect(j0.axis).toEqual(new Float64Array([0, 0, 1]));
expect(j0.type).toEqual(mujoco.mjtJoint.mjJNT_FREE.value);
const j0qposStart = model.jnt_qposadr[j0.id];
const j0qposEnd =
(j0.id < model.njnt - 1) ? model.jnt_qposadr[j0.id + 1] : model.nq;
const expectedJ0qpos = model.qpos0.slice(j0qposStart, j0qposEnd);
expectArraysEqual(
expectedJ0qpos, new Float64Array([0, 0, 1, 1, 0, 0, 0]));
expectArraysEqual(j0.qpos0, expectedJ0qpos);
const j0dofStart = model.jnt_dofadr[j0.id];
const j0dofEnd =
(j0.id < model.njnt - 1) ? model.jnt_dofadr[j0.id + 1] : model.nv;
const expectedJ0dof = model.dof_bodyid.slice(j0dofStart, j0dofEnd);
expectArraysEqual(expectedJ0dof, new Int32Array([1, 1, 1, 1, 1, 1]));
expectArraysEqual(j0.bodyid, expectedJ0dof);
const j1 = model.jnt('hinge');
expect(j1.id).toBe(1);
expect(j1.name).toBe('hinge');
expect(j1.type).toBe(mujoco.mjtJoint.mjJNT_HINGE.value);
expect(j1.qposadr).toBe(7);
expect(j1.dofadr).toBe(6);
expect(j1.axis).toEqual(new Float64Array([0, 1, 0]));
expect(j1.frictionloss).toEqual(new Float64Array([0.4]));
const j1qposStart = model.jnt_qposadr[j1.id];
const j1qposEnd =
(j1.id < model.njnt - 1) ? model.jnt_qposadr[j1.id + 1] : model.nq;
const expectedJ1qpos = model.qpos0.slice(j1qposStart, j1qposEnd);
expectArraysEqual(expectedJ1qpos, new Float64Array([0]));
expectArraysEqual(j1.qpos0, expectedJ1qpos);
const j1dofStart = model.jnt_dofadr[j1.id];
const j1dofEnd =
(j1.id < model.njnt - 1) ? model.jnt_dofadr[j1.id + 1] : model.nv;
const expectedJ1dof = model.dof_bodyid.slice(j1dofStart, j1dofEnd);
expectArraysEqual(expectedJ1dof, new Int32Array([2]));
expectArraysEqual(j1.bodyid, new Int32Array([2]));
} finally {
model?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
it('should support named access for HFields', () => {
const xml = `<mujoco model="test_hfield">
<asset>
<hfield name="hf" nrow="2" ncol="3" size="1 2 0.1 0.2"/>
</asset>
<worldbody>
<geom type="hfield" hfield="hf"/>
</worldbody>
</mujoco>`;
const tempXmlFilename = '/tmp/hf.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
try {
assertExists(model);
const hf = model.hfield('hf');
expect(hf.id).toBe(0);
expect(hf.name).toBe('hf');
expect(hf.nrow).toBe(2);
expect(hf.ncol).toBe(3);
expectArraysClose(hf.size, new Float64Array([1, 2, 0.1, 0.2]));
const expectedDataLength =
model.hfield_nrow[hf.id] * model.hfield_ncol[hf.id];
expect(expectedDataLength).toBe(6);
expect(hf.data.length).toBe(expectedDataLength);
} finally {
model?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
it('should support named access for Numeric', () => {
const xml = `<mujoco>
<custom>
<numeric name="n1" data="1 2 3"/>
<numeric name="n2" data="4 5 6 7"/>
</custom>
</mujoco>`;
const tempXmlFilename = '/tmp/num.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
try {
assertExists(model);
const n1 = model.numeric('n1');
const expectedN1data = model.numeric_data.slice(
model.numeric_adr[n1.id],
model.numeric_adr[n1.id] + model.numeric_size[n1.id]);
expect(n1.id).toBe(0);
expect(n1.name).toBe('n1');
expect(n1.size).toBe(3);
expect(expectedN1data).toEqual(new Float64Array([1, 2, 3]));
expectArraysClose(n1.data, expectedN1data);
const n2 = model.numeric('n2');
const expectedN2data = model.numeric_data.slice(
model.numeric_adr[n2.id],
model.numeric_adr[n2.id] + model.numeric_size[n2.id]);
expect(n2.id).toBe(1);
expect(n2.name).toBe('n2');
expect(n2.size).toBe(4);
expect(expectedN2data).toEqual(new Float64Array([4, 5, 6, 7]));
expectArraysClose(n2.data, expectedN2data);
} finally {
model?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
it('should support named access for Texture', () => {
const xml = `<mujoco>
<asset>
<texture name="t1" type="2d" builtin="checker" width="10"
height="12"/>
</asset>
</mujoco>`;
const tempXmlFilename = '/tmp/tex.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
try {
assertExists(model);
const t1 = model.tex('t1');
const texAdr = Number(model.tex_adr[t1.id]);
const expectedData = model.tex_data.slice(
texAdr,
texAdr +
model.tex_height[t1.id] * model.tex_width[t1.id] *
model.tex_nchannel[t1.id]);
expect(t1.id).toBe(0);
expect(t1.name).toBe('t1');
expect(t1.type).toBe(mujoco.mjtTexture.mjTEXTURE_2D.value);
expect(t1.width).toBe(10);
expect(t1.height).toBe(12);
expect(t1.nchannel).toBe(3);
expect(t1.data.length).toBe(t1.width * t1.height * t1.nchannel);
expectArraysClose(t1.data, expectedData);
} finally {
model?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
it('should support named access for Tuple', () => {
const xml = `<mujoco>
<worldbody>
<geom name="g1" type="sphere" size=".1"/>
<geom name="g2" type="box" size=".1 .1 .1"/>
</worldbody>
<custom>
<tuple name="tup1">
<element objtype="geom" objname="g1" prm="0.1"/>
<element objtype="geom" objname="g2" prm="0.2"/>
</tuple>
</custom>
</mujoco>`;
const tempXmlFilename = '/tmp/tup.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
try {
assertExists(model);
const t1 = model.tuple('tup1');
const expectedObjtype = model.tuple_objtype.slice(
model.tuple_adr[t1.id],
model.tuple_adr[t1.id] + model.tuple_size[t1.id]);
expect(t1.id).toBe(0);
expect(t1.name).toBe('tup1');
expect(t1.size).toBe(2);
expectArraysEqual(
expectedObjtype, new Int32Array([
mujoco.mjtObj.mjOBJ_GEOM.value, mujoco.mjtObj.mjOBJ_GEOM.value
]));
expectArraysEqual(t1.objtype, expectedObjtype);
} finally {
model?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
});
describe('MjData named access', () => {
it('should support named access for MjData', () => {
mujoco.mj_forward(model!, data!);
// Actuator
expect(model!.nu).toBe(1);
const actuator = data!.actuator(0);
expect(actuator.name).toBe('myactuator');
expect(actuator.velocity).toBe(0);
expect(actuator.force).toBe(0);
expectArraysClose(
actuator.moment, new Float64Array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
// Body
expect(model!.nbody).toBe(5);
expect(data!.body('mybox').name).toBe('mybox');
expectArraysClose(
data!.body('mybox').xpos, new Float64Array([0, 0, 0.1]));
expect(data!.body('myhinge-body').name).toBe('myhinge-body');
expectArraysClose(
data!.body('myhinge-body').xpos, new Float64Array([0, 0, 1]));
expect(data!.body('myball-body').name).toBe('myball-body');
expectArraysClose(
data!.body('myball-body').xpos, new Float64Array([2, 0, 1]));
expect(data!.body('mocap-body').name).toBe('mocap-body');
expectArraysClose(
data!.body('mocap-body').xpos, new Float64Array([42, 0, 42]));
// Geom
expect(model!.ngeom).toBe(3);
expect(data!.geom('myplane').name).toBe('myplane');
expectArraysClose(
data!.geom('myplane').xpos, new Float64Array([0, 0, 0]));
expectArraysClose(
data!.geom('myplane').xmat,
new Float64Array([1, 0, 0, 0, 1, 0, 0, 0, 1]));
expect(data!.geom('mybox').name).toBe('mybox');
expectArraysClose(
data!.geom('mybox').xpos, new Float64Array([0, 0, 0.1]));
expectArraysClose(
data!.geom('mybox').xmat,
new Float64Array([1, 0, 0, 0, 1, 0, 0, 0, 1]));
expect(data!.geom('mocap-sphere').name).toBe('mocap-sphere');
expectArraysClose(
data!.geom('mocap-sphere').xpos, new Float64Array([42, 0, 42]));
expectArraysClose(
data!.geom('mocap-sphere').xmat,
new Float64Array([1, 0, 0, 0, 1, 0, 0, 0, 1]));
// Joint
expect(model!.njnt).toBe(3);
const freeJnt = data!.jnt('myfree');
expect(freeJnt.name).toBe('myfree');
expectArraysClose(freeJnt.xanchor, new Float64Array([0, 0, 0.1]));
expectArraysClose(freeJnt.xaxis, new Float64Array([0, 0, 1]));
const hingeJnt = data!.jnt('myhinge');
expect(hingeJnt.name).toBe('myhinge');
expectArraysClose(hingeJnt.xanchor, new Float64Array([0, 0, 1]));
expectArraysClose(hingeJnt.xaxis, new Float64Array([0, 1, 0]));
const ballJnt = data!.jnt('myball');
expect(ballJnt.name).toBe('myball');
expectArraysClose(ballJnt.xanchor, new Float64Array([2, 0, 1]));
expectArraysClose(ballJnt.xaxis, new Float64Array([0, 0, 1]));
// Sensor
expect(model!.nsensor).toBe(2);
const jointvelSensor = data!.sensor('myjointvel');
expect(jointvelSensor.name).toBe('myjointvel');
expectArraysClose(jointvelSensor.data, new Float64Array([0]));
const accelSensor = data!.sensor('myaccelerometer');
expect(accelSensor.name).toBe('myaccelerometer');
expectArraysClose(accelSensor.data, new Float64Array([0, 0, 9.81]));
// Site
expect(model!.nsite).toBe(1);
const site = data!.site('mysite');
expect(site.name).toBe('mysite');
expectArraysClose(site.xpos, new Float64Array([0, 0, 0]));
expectArraysClose(
site.xmat, new Float64Array([1, 0, 0, 0, 1, 0, 0, 0, 1]));
});
// Corresponds to bindings_test.py:test_indexer_name_id
it('should support named and indexed access for MjData geoms', () => {
const xml = `
<mujoco>
<worldbody>
<geom name="mygeom" size="1" pos="0 0 1"/>
<geom size="2" pos="0 0 2"/>
<geom size="3" pos="0 0 3"/>
<geom name="myothergeom" size="4" pos="0 0 4"/>
<geom size="5" pos="0 0 5"/>
</worldbody>
</mujoco>
`;
const tempXmlFilename = '/tmp/geom_idx.xml';
writeXMLFile(tempXmlFilename, xml);
const model = mujoco.MjModel.mj_loadXML(tempXmlFilename);
const data = new mujoco.MjData(model);
try {
assertExists(model);
assertExists(data);
mujoco.mj_forward(model, data);
expect(data.geom('mygeom').id).toBe(0);
expect(data.geom('myothergeom').id).toBe(3);
expect(data.geom(0).name).toBe('mygeom');
expect(data.geom(1).name).toBe('');
expect(data.geom(2).name).toBe('');
expect(data.geom(3).name).toBe('myothergeom');
expect(data.geom(4).name).toBe('');
expect(data.geom(0).xpos[2]).toBeCloseTo(1);
expect(data.geom(1).xpos[2]).toBeCloseTo(2);
expect(data.geom(2).xpos[2]).toBeCloseTo(3);
expect(data.geom(3).xpos[2]).toBeCloseTo(4);
expect(data.geom(4).xpos[2]).toBeCloseTo(5);
} finally {
model?.delete();
data?.delete();
unlinkXMLFile(tempXmlFilename);
}
});
// Corresponds to bindings_test.py:test_named_indexing_invalid_names_in_data
it('should throw an error for invalid geom names in data', () => {
expect(() => {
data!.geom('badgeom');
})
.toThrowError(
`MuJoCo Error: Invalid name 'badgeom' for geom. Valid names: ['mocap-sphere', 'mybox', 'myplane']`);
});
// Corresponds to bindings_test.py:test_named_indexing_invalid_index_in_data
it('should throw an error for invalid geom indices in data', () => {
expect(() => {
data!.geom(3);
})
.toThrowError(
'MuJoCo Error: Invalid index 3 for geom. Valid indices from 0 to 2');
expect(() => {
data!.geom(-1);
})
.toThrowError(
'MuJoCo Error: Invalid index -1 for geom. Valid indices from 0 to 2');
});
// Corresponds to bindings_test.py:test_named_indexing_actuator_ctrl
it('should support named access for Actuator ctrl', () => {
const actuatorId = mujoco.mj_name2id(
model!, mujoco.mjtObj.mjOBJ_ACTUATOR.value, 'myactuator');
assertExists(actuatorId);
const actuator = data!.actuator('myactuator');
expect(actuator).toEqual(data!.actuator(actuatorId));
expect(actuator.ctrl).toEqual(data!.actuator(actuatorId)!.ctrl);
// Test that the indexer is returning a view into the underlying
data!.ctrl[actuatorId] = 5;
expect(actuator.ctrl).toBe(5);
actuator.ctrl = 7;
expect(data!.ctrl[actuatorId]).toBe(7);
});
// Corresponds to bindings_test.py:test_named_indexing_ragged_qpos
it('should support named access for Joint qpos', () => {
const balljointId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_JOINT.value, 'myball');
assertExists(balljointId);
const ballJnt = data!.jnt('myball');
expect(ballJnt).toEqual(data!.jnt(balljointId));
expect(ballJnt.qpos).toEqual(data!.jnt(balljointId)!.qpos);
// Test that the indexer is returning a view into the underlying struct.
const qposFromIndexer = ballJnt.qpos;
const qposIdx = model!.jnt_qposadr[balljointId];
data!.qpos.set([4, 5, 6, 7], qposIdx);
expectArraysEqual(qposFromIndexer, new Float64Array([4, 5, 6, 7]));
ballJnt.qpos.set(new Float64Array([9, 8, 7, 6]))
expectArraysEqual(
data!.qpos.slice(qposIdx, qposIdx + 4),
new Float64Array([9, 8, 7, 6]));
});
// Corresponds to bindings_test.py:test_named_indexing_ragged2d_cdof
it('should support named access for Joint cdof', () => {
const freejointId =
mujoco.mj_name2id(model!, mujoco.mjtObj.mjOBJ_JOINT.value, 'myfree');
assertExists(freejointId);
mujoco.mj_forward(model!, data!);
const freeJnt = data!.jnt('myfree');
expect(freeJnt).toEqual(data!.jnt(freejointId));
expect(freeJnt.cdof).toEqual(data!.jnt(freejointId)!.cdof);
expect(freeJnt.cdof.length).toBe(36); // 6x6
// Test that the indexer is returning a view into the underlying
const cdofFromIndexer = freeJnt.cdof;
const dofIdx = model!.jnt_dofadr[freejointId];
const testArray = new Float64Array(36);
for (let i = 0; i < 36; i++) {
testArray[i] = i;
}
data!.cdof.set(testArray);
expectArraysEqual(freeJnt.cdof, testArray);
const expectedCdof = new Float64Array(36).fill(42);
freeJnt.cdof.set(expectedCdof);
expectArraysEqual(data!.cdof.slice(dofIdx, dofIdx + 36), expectedCdof);
});
});
it('should save model to buffer', () => {
assertExists(model);
const modelSize = mujoco.mj_sizeModel(model);
const buffer = new mujoco.Uint8Buffer(Number(modelSize));
try {
mujoco.mj_saveModel(model, null, buffer);
// Test the first 3 byte values of the buffer.
expect(buffer.GetView()[0]).toBe(49);
expect(buffer.GetView()[1]).toBe(212);
expect(buffer.GetView()[2]).toBe(0);
} finally {
buffer.delete();
}
});
it('should save model to file', () => {
assertExists(model);
const filename = '/tmp/test.mjb';
const modelSize = mujoco.mj_sizeModel(model);
const buffer = new mujoco.Uint8Buffer(Number(modelSize));
try {
mujoco.mj_saveModel(model, filename, null);
const fileContent =
(mujoco as any).FS.readFile(filename, {encoding: 'binary'});
mujoco.mj_saveModel(model, null, buffer);
const bufferContent = buffer.GetView();
expect(fileContent.length).toBe(bufferContent.length);
expect(fileContent).toEqual(bufferContent);
} finally {
buffer.delete();
unlinkXMLFile(filename);
}
});
it('should load and save a model with assets to binary', () => {
const xmlContent = `
<mujoco model="test_binary_save">
<asset>
<mesh file="cube.obj"/>
</asset>
<worldbody>
<geom type="mesh" mesh="cube"/>
</worldbody>
</mujoco>`;
const cube1 = `
v -1 -1 1
v 1 -1 1
v -1 1 1
v 1 1 1
v -1 1 -1
v 1 1 -1
v -1 -1 -1
v 1 -1 -1`;
const xmlFilename = '/tmp/binary_test.xml';
const objFilename = '/tmp/cube.obj';
const mjbFilename = '/tmp/binary_test.mjb';
writeXMLFile(xmlFilename, xmlContent);
writeXMLFile(objFilename, cube1);
let model: MjModel|null = null;
let binaryModel: MjModel|null = null;
let vfs: MjVFS|null = null;
try {
model = mujoco.MjModel.mj_loadXML(xmlFilename);
assertExists(model);
mujoco.mj_saveModel(model, mjbFilename, null);
vfs = new mujoco.MjVFS();
vfs.addBuffer(objFilename, new TextEncoder().encode(cube1));
binaryModel = mujoco.MjModel.mj_loadBinary(mjbFilename, vfs);
assertExists(binaryModel);
expect(mujoco.mj_sizeModel(binaryModel))
.toEqual(mujoco.mj_sizeModel(model));
expect(binaryModel.nbody).toEqual(model!.nbody);
expect(binaryModel.nq).toEqual(model!.nq);
expect(binaryModel.nv).toEqual(model!.nv);
expect(binaryModel.njnt).toEqual(model!.njnt);
expect(binaryModel.nmesh).toEqual(model!.nmesh);
} finally {
model?.delete();
binaryModel?.delete();
vfs?.delete();
unlinkXMLFile(xmlFilename);
unlinkXMLFile(objFilename);
unlinkXMLFile(mjbFilename);
}
});
// Corresponds to bindings_test.py:test_mj_saveModel
it('should save and load a model from binary', () => {
const mjbFilename = '/tmp/saved_model.mjb';
let binaryModel: MjModel|null = null;
let vfs: MjVFS|null = null;
try {
mujoco.mj_saveModel(model!, mjbFilename, null);
const bufSize = mujoco.mj_sizeModel(model!);
vfs = new mujoco.MjVFS();
binaryModel = mujoco.MjModel.mj_loadBinary(mjbFilename, vfs);
assertExists(binaryModel);
expect(mujoco.mj_sizeModel(binaryModel)).toEqual(bufSize);
expect(binaryModel.nbody).toEqual(model!.nbody);
expect(binaryModel.nq).toEqual(model!.nq);
expect(binaryModel.nv).toEqual(model!.nv);
expect(binaryModel.njnt).toEqual(model!.njnt);
expect(binaryModel.nmesh).toEqual(model!.nmesh);
} finally {
binaryModel?.delete();
vfs?.delete();
unlinkXMLFile(mjbFilename);
}
});
});
Reference in New Issue View Git Blame Copy Permalink