How to use the cesium.Math function in cesium

function getExtent(mn, mx) {
    const e = new Cesium.Rectangle()

    // Re-order so west < east and south < north
    e.west = Math.min(mn.longitude, mx.longitude)
    e.east = Math.max(mn.longitude, mx.longitude)
    e.south = Math.min(mn.latitude, mx.latitude)
    e.north = Math.max(mn.latitude, mx.latitude)

    // Check for approx equal (shouldn't require abs due to re-order)
    const epsilon = Cesium.Math.EPSILON7

    if (e.east - e.west < epsilon) {
      e.east += epsilon * 2.0
    }

    if (e.north - e.south < epsilon) {
      e.north += epsilon * 2.0
    }

    return e
  }

modelToRectangle(model) {
    const toRad = Cesium.Math.toRadians
    const obj = model.toJSON()
    if (
      _.every(defaultAttrs, val => _.isUndefined(obj[val])) ||
      _.isEmpty(obj)
    ) {
      if (this.options.map.scene && this.options.map.scene.primitives) {
        this.options.map.scene.primitives.remove(this.primitive)
      }
      this.stopListening()
      return
    }
    _.each(obj, (val, key) => {
      obj[key] = toRad(val)
    })
    const rectangle = new Cesium.Rectangle()
    if (

handler.setInputAction(function (movement) {
                    cartesian = scene.getCamera().controller.pickEllipsoid(movement.endPosition, ellipsoid);
                    if (cartesian) {
                        cartographic = ellipsoid.cartesianToCartographic(cartesian);
                        label.setShow(true);
                        label.setText('(' + Cesium.Math.toDegrees(cartographic.longitude).toFixed(2) + ', ' + Cesium.Math.toDegrees(cartographic.latitude).toFixed(2) + ')');
                        label.setPosition(cartesian);
                    } else {
                        label.setText('');
                    }
                }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);

function updateCoordinatesTooltip(position) {
    const cartesian = map.camera.pickEllipsoid(
      position,
      map.scene.globe.ellipsoid
    )
    if (Cesium.defined(cartesian)) {
      let cartographic = Cesium.Cartographic.fromCartesian(cartesian)
      mapModel.updateMouseCoordinates({
        lat: cartographic.latitude * Cesium.Math.DEGREES_PER_RADIAN,
        lon: cartographic.longitude * Cesium.Math.DEGREES_PER_RADIAN,
      })
    } else {
      mapModel.clearMouseCoordinates()
    }
  }

var createBuildingsTile = require('../lib/createBuildingsTile');
var createB3dm = require('../lib/createB3dm');
var createCmpt = require('../lib/createCmpt');
var createI3dm = require('../lib/createI3dm');
var createInstancesTile = require('../lib/createInstancesTile');
var createPointCloudTile = require('../lib/createPointCloudTile');
var createTilesetJsonSingle = require('../lib/createTilesetJsonSingle');
var getProperties = require('../lib/getProperties');
var saveTile = require('../lib/saveTile');
var saveTilesetJson = require('../lib/saveTilesetJson');
var util = require('../lib/utility');

var processGlb = gltfPipeline.processGlb;

var Cartesian3 = Cesium.Cartesian3;
var CesiumMath = Cesium.Math;
var clone = Cesium.clone;
var defaultValue = Cesium.defaultValue;
var defined  = Cesium.defined;
var Matrix4 = Cesium.Matrix4;
var Quaternion = Cesium.Quaternion;

var lowercase = util.lowercase;
var metersToLongitude = util.metersToLongitude;
var metersToLatitude = util.metersToLatitude;
var wgs84Transform = util.wgs84Transform;

var prettyJson = true;
var gzip = false;

var outputDirectory = 'output';

'use strict';
var Cesium = require('cesium');
var clone = require('clone');

var Cartesian3 = Cesium.Cartesian3;
var GeometryPipeline = Cesium.GeometryPipeline;
var WebGLConstants = Cesium.WebGLConstants;
var CesiumMath = Cesium.Math;
var defaultValue = Cesium.defaultValue;
var defined = Cesium.defined;

var RemoveUnusedProperties = require('./RemoveUnusedProperties');
var addExtensionsUsed = require('./addExtensionsUsed');
var cesiumGeometryToGltfPrimitive = require('./cesiumGeometryToGltfPrimitive');
var createAccessor = require('./createAccessor');
var gltfPrimitiveToCesiumGeometry = require('./gltfPrimitiveToCesiumGeometry');
var getPrimitiveAttributeSemantics = require('./getPrimitiveAttributeSemantics');
var getUniqueId = require('./getUniqueId');
var mergeBuffers = require('./mergeBuffers');
var processModelMaterialsCommon = require('./processModelMaterialsCommon');
var packArray = require('./packArray');
var readAccessor = require('./readAccessor');
var techniqueParameterForSemantic = require('./techniqueParameterForSemantic');
var writeAccessor = require('./writeAccessor');

'use strict';
const fsExtra = require('fs-extra');
const path = require('path');
const dataUriToBuffer = require('../../lib/dataUriToBuffer');
const ForEach = require('../../lib/ForEach');
const readResources = require('../../lib/readResources');
const writeResources = require('../../lib/writeResources');

const Cesium = require('cesium');
const CesiumMath = Cesium.Math;

const gltfPath = 'specs/data/2.0/box-techniques-embedded/box-techniques-embedded.gltf';
const gltfWebpPath = 'specs/data/2.0/extensions/EXT_texture_webp/box-textured-embedded/box-textured-embedded.gltf';
const gltfWebpSeparatePath = 'specs/data/2.0/extensions/EXT_texture_webp/box-textured-separate/box-textured-with-fallback.gltf';
let gltf;
let gltfWebp;
let gltfWebpSeparate;

describe('writeResources', () => {
    beforeEach(async () => {
        gltf = fsExtra.readJsonSync(gltfPath);
        gltfWebp = fsExtra.readJsonSync(gltfWebpPath);
        gltfWebpSeparate = fsExtra.readJsonSync(gltfWebpSeparatePath);

        await readResources(gltf);
        await readResources(gltfWebp);

'use strict';
var path = require('path');
var Cesium = require('cesium');
var createSingleTileset = require('./createSingleTileset');
var tilesetOptionsUtility = require('./tilesetOptionsUtility');
var obj2B3dm = require('./obj2B3dm');
var obj2I3dm = require('./obj2I3dm');
var Cartesian3 = Cesium.Cartesian3;
var Matrix3 = Cesium.Matrix3;
var CMath = Cesium.Math;

var defaultValue = Cesium.defaultValue;
var getPoint3MinMax = tilesetOptionsUtility.getPoint3MinMax;

module.exports = obj2Tileset;

function obj2Tileset(objPath, outputpath, options) {
    var folder = path.dirname(outputpath);
    var tileFullName = path.basename(outputpath);
    var folderPrifix = options.b3dm ? 'Batched' : 'Instanced';
    var tilesetFolderName = folderPrifix + path.basename(objPath, '.obj');
    var tilePath = path.join(folder, tilesetFolderName, tileFullName);
    var tilesetPath = path.join(folder, tilesetFolderName, 'tileset.json');
    var tilesetOptions = options.tilesetOptions || {};
    if (options.b3dm) {
        return obj2B3dm(objPath, options)

setModelFromClicks(mn, mx) {
    let e = new Cesium.Rectangle(),
      epsilon = Cesium.Math.EPSILON14,
      modelProps

    if (!this.lastLongitude) {
      this.crossDateLine = false
      this.lastLongitude = mx.longitude
    } else {
      if (this.lastLongitude > 0 && mx.longitude > 0 && mn.longitude > 0) {
        //west of the date line
        this.crossDateLine = false
        //track direction of the bbox
        if (this.lastLongitude > mx.longitude) {
          if (this.dir === 'east') {
            if (mx.longitude < mn.longitude) {
              this.dir = 'west'
            }
          } else {

'use strict';
var Cesium = require('cesium');
var clone = require('clone');

var CesiumMath = Cesium.Math;
var Cartesian3 = Cesium.Cartesian3;
var Matrix4 = Cesium.Matrix4;

var bakeAmbientOcclusion = require('../../lib/bakeAmbientOcclusion');
var NodeHelpers = require('../../lib/NodeHelpers');
var readGltf = require('../../lib/readGltf');
var StaticUniformGrid = require('../../lib/StaticUniformGrid');

var generateOptions = bakeAmbientOcclusion._generateOptions;
var generateRaytracerScene = bakeAmbientOcclusion._generateRaytracerScene;
var computeAmbientOcclusionAt = bakeAmbientOcclusion._computeAmbientOcclusionAt;
var raytraceAtTriangleCenters = bakeAmbientOcclusion._raytraceAtTriangleCenters;
var raytraceOverTriangleSamples = bakeAmbientOcclusion._raytraceOverTriangleSamples;
var extractInstructionWithFunctionCall = bakeAmbientOcclusion._extractInstructionWithFunctionCall;
var injectGlslAfterInstructionContaining = bakeAmbientOcclusion._injectGlslAfterInstructionContaining;