Created a model of the One World Trade Center antiprism

[raydeleu]

Inspired by Matt Parker, https://www.youtube.com/watch?v=a_fTA4UeFls, I created the following model of the One World Trade Center. The model illustrates how to use the makePolygon and makeSolid functions of Replicad. Modelling this shape was not straightforward. You can tell by the code that I needed some tricks to make it work. The code can be improved to create antiprisms of other regular polygons. This would require a more generic approach to define the rotation of the top plane versus the base plane and to define the faces on the top and bottom. For now I am happy with the result.

To make it easier to copy the code I have included it below:

const {draw, drawRectangle, makePolygon, makeSolid} = replicad;

function main()
{
let bL = 200/10;  // base length is 200 ft
let h = 1368/10;  // height 1368 ft
let m = (60/0.3048)/10; // first 60 meters are straight, converted to feet

    function antiPrism(bLength,prismHeight,endScale)
    {
        let bL = bLength/2;
        let tL = bL/Math.sin(Math.PI/4)
        let base=[]
        base[1] = [-bL,-bL,0];
        base[2] = [bL,-bL,0];
        base[3] = [bL,bL,0];
        base[4] = [-bL,bL,0];
        base[5] = base[1]   // trick to avoid need for modulus 4

        let top=[]
        top[1] = [0  ,-tL*endScale ,prismHeight]
        top[2] = [tL*endScale  , 0  ,prismHeight]
        top[3] = [0 ,tL*endScale  ,prismHeight]
        top[4] = [-tL*endScale ,0   ,prismHeight]
        top[5] = top[1]    // trick to avoid need for modulus 4

        let face=[]
        face[1] = makePolygon([base[1],base[4],base[3],base[2]]);        
        // not defined counterclockwise to have face facing in negative z-direction
        for (let i=2 ; i<=8; i+=2)
            {
            face[i]     = makePolygon([top[i/2],base[i/2],base[i/2+1]]);
            face[i+1]   = makePolygon([base[i/2+1],top[i/2+1],top[i/2]]);
            }
        face[10] = makePolygon([top[1],top[2],top[3],top[4]]);
        return face;
        }
let faces = antiPrism(bL,h,Math.sin(Math.PI/4));
let tower = makeSolid(faces).translate(0,0,m);
let towerbase = drawRectangle(bL,bL).sketchOnPlane("XY").extrude(m)
tower = tower.fuse(towerbase)
return tower}

[raydeleu]

Using the modelling approach shown here https://youtu.be/S5O9ksOGO9A?si=-c-b1SQFuK6qwoEy I created the following result.

The approach consists of modelling 4 piramids that are then subtracted from a standard prism shape to create the antiprism. The result is the rotated 180 degrees to let the small top point upwards. Then the prism-shaped base of the tower is added. To make the result more realistic I added the top part and the spike.

The code illustrates that it is possible to approximate a piramid shape by extruding with a very small endFactor. The program crashes at endFactor: 0, so the best I could achieve was an approximation. The rest of the steps are taken directly from the approach shown in the YouTube video.

const {draw,drawRectangle,drawCircle,makeCylinder} = replicad

function main()
{
let scale = 1/10
let baseLength = 200*scale;
let topLength = Math.sqrt((2*Math.pow((baseLength/2),2)))
let totalHeight = 1368*scale
let baseHeight = 196.85*scale
let heightTop = (totalHeight-baseHeight)
let cylinderHeight = 50*scale
let spikeHeight = 250*scale
let spikeBaseR = 10*scale

// create 4 piramids to shave off triangles from prism
let pMid1 = drawRectangle(topLength,topLength).sketchOnPlane("XY")
.extrude(heightTop,{extrusionProfile: {profile: "linear", endFactor: 0.01}})
.rotate(45,[0,0]).translate(-baseLength/2,-baseLength/2)
let pMid2 = pMid1.clone().translate(baseLength,0)
let pMid3 = pMid1.clone().translate(0,baseLength)
let pMid4 = pMid1.clone().translate(baseLength,baseLength)

// create straight segment, cut with piramids, rotate and translate
let baseProfile = drawRectangle(baseLength,baseLength).sketchOnPlane("XY")
let towerTop = baseProfile.clone().extrude(heightTop)
towerTop = towerTop.cut(pMid1).cut(pMid2).cut(pMid3).cut(pMid4)
towerTop = towerTop.rotate(180,[0,0,0],[0,1,0]).translate(0,0,totalHeight)
let towerBase = baseProfile.extrude(baseHeight)
let tower = towerBase.fuse(towerTop)
let topCylinder = makeCylinder(topLength/1.8,5).translate(0,0,totalHeight)
tower = tower.fuse(topCylinder);
let spike = drawCircle(spikeBaseR).sketchOnPlane("XY")
spike = spike.extrude(spikeHeight,{extrusionProfile: {profile: "linear", endFactor: 0.01}})
.translate(0,0,totalHeight+cylinderHeight)
tower = tower.fuse(spike)

return [{shape: tower}]}

[raydeleu]

To complete my set of experiments I tried to create the shape using the loftWith method, but this failed. If you only use the base and top planes, the result is a twisted shape. I hoped to trigger a better result using a mid profile of an octagon, but the opencascade kernel then tries to create smaller rectangular faces between the profiles instead of triangular faces.