大道废

viewer.screenSpaceEventHandler.setInputAction((event) => {
        let picked = viewer.scene.pick(event.endPosition);
        if (picked !== prePicked) {
                if (prePicked) prePicked.color = preStyle;
                if (picked) {
                        prePicked = picked, preStyle = picked.color;
                        picked.color = Cesium.Color.YELLOW.withAlpha(0.5);
                }
        }
}, Cesium.ScreenSpaceEventType.MOUSE_MOVE);

let hierarchy = entity.polyline.positions._value;
        hierarchy = Cesium.PolylinePipeline.generateArc({
            positions: hierarchy,
        });
        let vector = new Cesium.Cartesian3();
        let distance = 0;
        for (let i = 3; i < hierarchy.length; i += 3) {
            vector.x = hierarchy[i] - hierarchy[i - 3];
            vector.y = hierarchy[i + 1] - hierarchy[i - 2];
            vector.z = hierarchy[i + 2] - hierarchy[i - 1];
            distance += Cesium.Cartesian3.magnitude(vector);
        }

// Get the polygon from your "entity"
var polygon = theEntity.polygon;
var hierarchy = polygon.hierarchy._value;
// "indices" here defines an array, elements of which defines the indice of a vector
// defining one corner of a triangle. Add up the areas of those triangles to get
// an approximate area for the polygon
var indices = Cesium.PolygonPipeline.triangulate(hierarchy.positions, hierarchy.holes);
var area = 0; // In square kilometers
for (var i = 0; i < indices.length; i += 3) {
  var vector1 = hierarchy.positions[indices[i]];
  var vector2 = hierarchy.positions[indices[i+1]];
  var vector3 = hierarchy.positions[indices[i+2]];
  // These vectors define the sides of a parallelogram (double the size of the triangle)
  var vectorC = Cesium.Cartesian3.subtract(vector2, vector1, new Cesium.Cartesian3());
  var vectorD = Cesium.Cartesian3.subtract(vector3, vector1, new Cesium.Cartesian3());
  // Area of parallelogram is the cross product of the vectors defining its sides
  var areaVector = Cesium.Cartesian3.cross(vectorC, vectorD, new Cesium.Cartesian3());
  
  // Area of the triangle is just half the area of the parallelogram, add it to the sum.
  area += Cesium.Cartesian3.magnitude(areaVector)/2.0;
}

let long = -1.2917727072831369, lat = 0.7105749513910979, height = 547.7591871983744;
let heading = viewer.camera.heading, pitch = viewer.camera.pitch;

let position = viewer.scene.globe.ellipsoid.cartographicToCartesian(new Cesium.Cartographic(long, lat, 0.5 * height));
let offset = offsetFromHeadingPitchRange(heading, pitch, height * 2.0);
let transform = Cesium.Transforms.eastNorthUpToFixedFrame(position);
Cesium.Matrix4.multiplyByPoint(transform, offset, position);

function offsetFromHeadingPitchRange(heading, pitch, range) {
            pitch = Cesium.Math.clamp(pitch, -Cesium.Math.PI_OVER_TWO, Cesium.Math.PI_OVER_TWO);
            heading = Cesium.Math.zeroToTwoPi(heading) - Cesium.Math.PI_OVER_TWO;
            var pitchQuat = Cesium.Quaternion.fromAxisAngle(Cesium.Cartesian3.UNIT_Y, -pitch);
            var headingQuat = Cesium.Quaternion.fromAxisAngle(Cesium.Cartesian3.UNIT_Z, -heading);
            var rotQuat = Cesium.Quaternion.multiply(headingQuat, pitchQuat, headingQuat);
            var rotMatrix = Cesium.Matrix3.fromQuaternion(rotQuat);
            var offset = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_X);
            Cesium.Matrix3.multiplyByVector(rotMatrix, offset, offset);
            Cesium.Cartesian3.negate(offset, offset);
            Cesium.Cartesian3.multiplyByScalar(offset, range, offset);
            return offset;
}

Cesium.Camera.DEFAULT_VIEW_FACTOR = -0.3;
Cesium.Camera.DEFAULT_VIEW_RECTANGLE = tileset._root._boundingVolume.rectangle;

let coordinate = viewer.camera.pickEllipsoid(event.position, viewer.scene.globe.ellipsoid);
coordinate = Cesium.Cartographic.fromCartesian(coordinate);
Cesium.sampleTerrainMostDetailed(viewer.terrainProvider, [coordinate]).then((samples) => {
            for (let sample of samples) sample.height += 10.0;
            viewer.entities.add({
                position: Cesium.Cartographic.toCartesian(samples[0], viewer.scene.globe.ellipsoid),
                point: {
                    pixelSize: 5,
                    color: Cesium.Color.GREEN,
                    heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
                },
            });
        });

let ray = viewer.camera.getPickRay(event.position);
        let positon = viewer.scene.globe.pick(ray, viewer.scene);
        viewer.entities.add({
            position: positon,
            point: {
                pixelSize: 5,
                color: Cesium.Color.LIME,     
                heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,       
            },
        });

//Add button to View Aircraft at a Fixed Angle relative to aircraft
Sandcastle.addToolbarButton('View Aircraft Fixed Angle', function () {
    viewer.trackedEntity = undefined;
    viewer.clock.onTick.addEventListener(function (clock) {

        //get 2 positions close together timewise
        var CC3 = Cesium.Cartesian3;
        var position1 = entity.position.getValue(clock.currentTime, new CC3());
        var position2 = entity.position.getValue(Cesium.JulianDate.addSeconds(clock.currentTime, 1 / 60, new Cesium.JulianDate()), new CC3());

        //velocity in terms of Earth Fixed        
        var Wvelocity = CC3.subtract(position2, position1, new CC3());
        CC3.normalize(Wvelocity, Wvelocity);
        var Wup = new CC3(); var Weast = new CC3(); var Wnorth = new CC3();
        Cesium.Ellipsoid.WGS84.geodeticSurfaceNormal(position1, Wup);
        CC3.cross({ x: 0, y: 0, z: 1 }, Wup, Weast);
        CC3.cross(Wup, Weast, Wnorth);

        //velocity in terms of local ENU
        var Lvelocity = new CC3();
        Lvelocity.x = CC3.dot(Wvelocity, Weast);
        Lvelocity.y = CC3.dot(Wvelocity, Wnorth);
        Lvelocity.z = CC3.dot(Wvelocity, Wup);

        //angle of travel
        var Lup = new CC3(0, 0, 1); var Least = new CC3(1, 0, 0); var Lnorth = new CC3(0, 1, 0);
        var x = CC3.dot(Lvelocity, Least);
        var y = CC3.dot(Lvelocity, Lnorth);
        var z = CC3.dot(Lvelocity, Lup);
        var angle = Math.atan2(x, y);//math: y b4 x, heading: x b4 y
        var pitch = Math.asin(z);//make sure Lvelocity is unitized

        //angles offsets
        angle += 0 / 180 * Math.PI;
        pitch += -20 / 180 * Math.PI;

        var range = 80;
        var offset = new Cesium.HeadingPitchRange(angle, pitch, range);
        viewer.scene.camera.lookAt(entity.position.getValue(clock.currentTime), offset);
    }); //end event listener
}); //end button

let n = 180, points = [];
let center = tileset.boundingSphere.center, radius = tileset.boundingSphere.radius;
let R = viewer.scene.globe.ellipsoid.maximumRadius; //地球半径
center = Cesium.Cartographic.fromCartesian(center); //转成经纬度坐标
//latB = latA-((radius * Math.sin(Math.PI * i / n)) * 180) / (Math.PI * ellipsoid.R)
//latB = LatA-(Y*180)/(Math.PI * e)
//loB = loA - ((rdius * Math.cost(Math.PI * i / n)) * 180) / (Math.PI * ellipsoid.R * Math.cos((LatA + LatB) / 2))
//loB = loA - (x*180)/(math.pi * r * cost((latA + latB) / 2))
for (let i = -n; i <= n; i++) {
    let x = Math.cos(Math.PI * i / n) * radius;
    let y = Math.sin(Math.PI * i / n) * radius;
    //let LatB = center.latitude - (y * 180) / (Math.PI * R);
    let LatB = center.latitude - (y / R);
    //let LonB = center.longitude - (x * 180) / (Math.PI * R * Math.cos((center.latitude + LatB) / 2));
    let LonB = center.longitude - (x / (R * Math.cos((center.latitude + LatB) / 2)));
    let point = new Cesium.Cartographic(LonB, LatB);
    point = viewer.scene.globe.ellipsoid.cartographicToCartesian(point);
    points.push(point);
}

Cesium.when(Cesium.sampleTerrainMostDetailed(viewer.terrainProvider, pointsR), (samples) => {
    for (let sample of samples) sample.height += 10.0;
    viewer.entities.add({
        polyline: {
            positions: Cesium.Ellipsoid.WGS84.cartographicArrayToCartesianArray(samples),
            width: 5,
            material: Cesium.Color.WHITE,
        },
    });
});

var viewer = new Cesium.Viewer('cesiumContainer',
                               {timeline: false, animation: false});
var scene = viewer.scene;
var offsetX = 50, offsetY = -80;
var pos = Cesium.Cartesian3.fromDegrees(-75.1641667, 29.9522222);
var labels = scene.primitives.add(new Cesium.LabelCollection());
labels.add({
    position: pos,
    text: 'Another label',
    pixelOffset: new Cesium.Cartesian2(offsetX, offsetY)
});
var canvas = document.createElement('canvas');
canvas.width = Math.abs(offsetX);
canvas.height = Math.abs(offsetY);
var context2D = canvas.getContext('2d');
context2D.beginPath();
context2D.lineWidth = 3;
context2D.strokeStyle = '#ffffff';
context2D.moveTo((offsetX < 0) ? -offsetX : 0, (offsetY < 0) ? -offsetY : 0);
context2D.lineTo((offsetX < 0) ? 0 : offsetX, (offsetY < 0) ? 0 : offsetY);
context2D.stroke();
var billboards = scene.primitives.add(new Cesium.BillboardCollection());
var billboard = billboards.add({
    color : Cesium.Color.RED,
    image : canvas,
    pixelOffset: new Cesium.Cartesian2(offsetX * 0.5, offsetY * 0.5),
    position : pos
});

var modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(position, hprRollZero, Cesium.Ellipsoid.WGS84, converter);
    scene.primitives.add(new Cesium.DebugModelMatrixPrimitive({
        modelMatrix : modelMatrix,
        length : 300.0,
        width : 10.0
    }));