GSOF-3dWireFrame 1.0.0__py3-none-any.whl

GSOF_3dWireFrame/Example_F16.py

@@ -0,0 +1,141 @@
+#!/usr/bin/python
+"""
+ * Example_F16.py
+ * Created on: 31 May 2026
+ * Improved for: 31 May 2026
+ * Author: Guy Soffer
+ * Copyright (C) 2026 Guy Soffer
+"""
+import pygame, math
+from Lib3D.Object_WireFrame import Object_wireFrame
+from Lib3D.Assembly import Assembly
+#from Lib3D.Object_base import Object_base
+from Lib3D import Objects
+from Lib3D import WireFrame_display as DISP
+from F16_Class import F16_View, Commands, State 
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+WHITE = (255,255,255)
+BLUE = (220,220,255)
+BLACK = (0,0,0)
+RED = (255,0,0)
+GREEN = (0,255,0)
+PI = math.pi
+
+def drawWireFrame(screen, obj, color=None) -> None:
+    for line in obj.getLines():
+        x0, y0, z0 = line.p0
+        x1, y1, z1 = line.p1
+        lcolor = color
+        if lcolor == None:
+            lcolor = line.color
+        pygame.draw.line( screen, lcolor, (x0, y0), (x1, y1) ) #< Line from P0 to P1
+
+def clearScreen(screen, color=(255,255,255)) -> None:
+  screen.fill(color)
+    
+def newScreen(title="New", resX=SCREEN_WIDTH, resY=SCREEN_HEIGHT, color=WHITE):
+    screenSize = (resX, resY)
+    screen = pygame.display.set_mode( screenSize )
+    clearScreen(screen, color)
+    pygame.display.set_caption(title)
+    return screen
+
+if __name__ == "__main__":
+    import copy
+    ground = Object_wireFrame(
+       obj=Objects.net(25,25), color=(0,100,0))\
+       .scale(0.2)\
+       .rotate(x=math.pi/2, y=0, z=0)\
+       .translate(-250, -200, -250)\
+       .setOrigin()
+
+    f16 = F16_View()\
+          .scale(1.0)\
+          .translate(100, 100, -100).setOrigin()
+    f16.plane.color = BLACK
+
+    rotateBy = (0*3.14/4, 1*3.14/8, 0)
+    f16_1 = copy.deepcopy(f16)
+    f16_1.rotate(*rotateBy, centerAt=(100,100,-100))\
+         .setOrigin()
+    f16_1.plane.color = RED
+
+    rotateBy = (0*3.14/4, -1*3.14/8, 0)
+    f16_2 = copy.deepcopy(f16)
+    f16_2.translate(-100, -100, 100)\
+          .rotate(*rotateBy)\
+          .translate(100, 100, -100)\
+          .translate(-100, 0, 100)\
+          .setOrigin()
+    f16_2.plane.color = GREEN
+
+    world = Assembly(objects=(ground, f16, f16_1, f16_2))
+
+    pygame.init()
+    clock = pygame.time.Clock()
+    screen = newScreen("3D Wire Frame Shapes", SCREEN_WIDTH, SCREEN_HEIGHT, WHITE)
+    wireframe = DISP.WireFrame(screen, pygame.draw.line, f=50, scale=20.0)
+
+    fps = 30
+    dt = 1/fps
+    t = 0.0
+    camAngX_r = 0.0
+    camAngY_r = 0.0
+    camAngZ_r = 0.0
+    commands  = Commands()
+    mPosZ = 0.0
+    state = State(thrust_lbf=6000)
+    useMouse = True
+
+    run = True
+    while run:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+              run = False
+        ### Wait for next step time
+        keys = pygame.key.get_pressed()
+        state.thrust_lbf  += (keys[pygame.K_q] -keys[pygame.K_a])*200
+        commands.gearsDown_b += keys[pygame.K_b] -keys[pygame.K_g]
+        commands.gearsDown_b = min(1, max(0,commands.gearsDown_b))
+        state.wowNose_b  = bool(keys[pygame.K_2])
+        state.wowLeft_b  = bool(keys[pygame.K_1])
+        state.wowRight_b = bool(keys[pygame.K_3])
+        print(state.wowLeft_b, state.wowNose_b, state.wowRight_b)
+
+        if useMouse:
+            (mPosX, mPosY) = pygame.mouse.get_pos()
+            mPosZ += (keys[pygame.K_z] -keys[pygame.K_x])*2
+            x = mPosX/SCREEN_WIDTH -0.5
+            y = mPosY/SCREEN_HEIGHT -0.5
+            z = mPosZ/360
+        else:
+            x += 0.5*dt
+            y += 1*dt
+            z = 0
+        commands.rudder_d = z*30
+        commands.leftAliron_d   = -25*x
+        commands.rightAliron_d  = 25*x
+        commands.leftElevator = 0.5*commands.leftAliron_d +25*y
+        commands.rightElevator = 0.5*commands.rightAliron_d  +25*y
+        camAngX_r = y*PI
+        camAngY_r = z*PI
+        camAngZ_r = x*PI
+
+        world.reset()
+        f16.setControls(t, commands, state)
+        world.transform(rotate=(camAngX_r,camAngY_r,camAngZ_r), translate=(0,0,-1000))
+        #world.transform(rotate=(3.14/2, 0.0*3.14, 0), translate=(0,0,-1000))
+
+        ### Draw 3D world
+        clearScreen(screen, BLUE)
+        wireframe.draw(world)
+        
+        t += dt
+        clock.tick(30)
+        
+        ### Display output
+        pygame.display.flip()
+
+    pygame.quit()

GSOF_3dWireFrame/Example_dynamicWorld.py

@@ -0,0 +1,99 @@
+import pygame, math
+from Lib3D.Object_WireFrame import Object_wireFrame as Object
+from Lib3D.Assembly import Assembly
+from Lib3D import WireFrame_display as DISP
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+WHITE  = (255,255,255)
+YELLOW = (240,240,150)
+BLACK  = (0,0,0)
+PI = math.pi
+        
+def clearScreen(screen, color=(255,255,255)) -> None:
+  screen.fill(color)
+    
+def newScreen(title="New", resX=SCREEN_WIDTH, resY=SCREEN_HEIGHT, color=WHITE):
+    screenSize = (resX, resY)
+    screen = pygame.display.set_mode( screenSize )
+    clearScreen(screen, color)
+    pygame.display.set_caption(title)
+    return screen
+    
+if __name__ == "__main__":
+    import json
+    d = 4
+    solidHouse = Object(filename="./objects/house.json", color=(0,180,180), name="House").scale(10.0).setOrigin()
+    window = Object(filename="./objects/frame.json", color=(200,0,0), name="Window").setCenter(scale=0.8)
+    flexHouse = Assembly(objects = (
+        Object(filename="./objects/cube.json", color=(190,190,190), name="Body").translate(0,0,0 +d).setOrigin(),
+        Object(filename="./objects/pyramid.json", color=(90,90,90), name="Roof").translate(0,-2.5,0 +d).setOrigin(),
+        Assembly(objects=(window,), name="Window-Assy").translate(0,0,-1 +d).setOrigin(),
+        ),
+        connections=[
+          [[0,4],[1,0]], #< Point-4 of object-0 to point-0 of object-1
+          [[0,5],[1,1]], #< Point-5 of object-0 to point-1 of object-1
+          [[0,6],[1,2]], #< Point-6 of object-0 to point-2 of object-1
+          [[0,7],[1,3]]  #< Point-7 of object-0 to point-3 of object-1
+          ],
+          name="Flex-House"
+          ).scale(10).rotate(PI,0,0).setOrigin()
+
+    world = Assembly(objects = (
+        solidHouse.translate(0,0,0).setOrigin(),
+        flexHouse.translate(0,-0,0).setOrigin(),
+        ))
+    pygame.init()
+    clock = pygame.time.Clock()
+    screen = newScreen("3D Wire Frame Shapes", SCREEN_WIDTH, SCREEN_HEIGHT, WHITE)
+    wireframe = DISP.WireFrame(screen, pygame.draw.line, f=50, scale=80)
+    fps = 30
+    dt = 1/fps
+    t = 0.0
+    camAngX_r = 0.0
+    camAngY_r = 0.0
+    roofAng_r = 0.0
+    houseAng_r = 0.0
+    useMouse = True
+
+    run = True
+    while run:
+        ### Get inputs
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+              run = False
+
+        ### Calculate next step state
+        camAngX_r += 0.5*dt
+        camAngY_r += 1*dt
+        roofAng_r = (PI/4/2)*math.sin(2*PI*1*t)
+        houseAng_r = (PI/4)*math.sin(2*PI*1.5*t)
+        t += dt
+
+        ### Update 3D world
+        world.reset()
+        solidHouse.rotate(x=0,y=roofAng_r,z=houseAng_r)
+        roof = flexHouse.objects[1]
+        roof.rotate(x=0,y=roofAng_r,z=0)
+        window.rotate(x=0,y=0,z=10*t)
+        world.rotate(x=camAngX_r,y=camAngY_r,z=0)
+        world.translate(x=0,y=0,z=-600)
+
+        ### Draw 3D world
+        clearScreen(screen, YELLOW)
+        wireframe.draw(world)
+        
+        ### Wait for next step time
+        if useMouse:
+            (mPosX, mPosY) = pygame.mouse.get_pos()
+            camAngY_r = 0.01*(mPosX -SCREEN_WIDTH/2)
+            camAngX_r = 0.01*(mPosY -SCREEN_HEIGHT/2)
+        else:
+            camAngX_r += 0.5*dt
+            camAngY_r += 1*dt
+        clock.tick(30)
+        
+        ### Display output
+        pygame.display.flip()
+        
+    pygame.quit()

GSOF_3dWireFrame/Example_motionWorld.py

@@ -0,0 +1,75 @@
+import pygame
+from Lib3D.Object_WireFrame import Object_wireFrame as Object
+from Lib3D.Assembly import Assembly
+from Lib3D import Objects
+from Lib3D import WireFrame_display as DISP
+from modules import Controls
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+WHITE = (255,255,255)
+BLACK = (0,0,0)
+
+def clearScreen(screen, color=(255,255,255)) -> None:
+  screen.fill(color)
+
+def newScreen(title="New", resX=SCREEN_WIDTH, resY=SCREEN_HEIGHT, color=WHITE):
+    screenSize = (resX, resY)
+    screen = pygame.display.set_mode( screenSize )
+    clearScreen(screen, color)
+    pygame.display.set_caption(title)
+    return screen
+  
+if __name__ == "__main__":
+    house = Object(filename="./objects/house.json", color=(0,180,180))
+    world = Assembly(objects = (
+        house,
+        ))
+
+    pygame.init()
+    clock = pygame.time.Clock()
+    screen = newScreen("3D Wire Frame Shapes", SCREEN_WIDTH, SCREEN_HEIGHT, WHITE)
+    wireframe = DISP.WireFrame(screen, pygame.draw.line, f=50, scale=10)
+    viewer = Controls.Viewer( pos=(0,0,-400),
+                              center=(int(screen.get_width()/2), int(screen.get_height()/2)),
+                              moveLeftKey  = pygame.K_a,
+                              moveRightKey = pygame.K_d,
+                              moveUpKey    = pygame.K_UP,
+                              moveDownKey  = pygame.K_DOWN,
+                              moveFwdKey   = pygame.K_w,
+                              moveBackKey  = pygame.K_x,
+                              tiltLeft     = pygame.K_COMMA,
+                              tiltRight    = pygame.K_PERIOD
+                             )
+
+    fps = 30
+    dt = 1/fps
+    t = 0.0
+    run = True
+
+    while run:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                run = False
+
+        keys = pygame.key.get_pressed()
+        (mPosX, mPosY) = pygame.mouse.get_pos()
+        wireframe.f += -(keys[pygame.K_1] - keys[pygame.K_2])*10
+        viewer.update(keys, mPosX, mPosY, speed=2)
+        
+        clearScreen(screen, WHITE)
+        world.reset()
+        world.translate(*viewer.getPosition())
+        world.rotate(*viewer.getAttitude())
+
+        ### Draw 3D world
+        clearScreen(screen, WHITE)
+        wireframe.draw(world)
+
+        ### Wait for next step time
+        clock.tick(30)
+
+        ### Display output
+        pygame.display.flip()
+
+    pygame.quit()

GSOF_3dWireFrame/Example_staticWorld.py

@@ -0,0 +1,112 @@
+import pygame, math
+from Lib3D.Object_WireFrame import Object_wireFrame as Object
+from Lib3D.Object_base import Object_base
+from Lib3D.Assembly import Assembly
+from Lib3D import WireFrame_display as DISP
+from Lib3D import Objects
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+WHITE = (255,255,255)
+BLACK = (0,0,0)
+PI = math.pi
+
+def drawWireFrame(screen, obj, color=None) -> None:
+    for line in obj.getLines():
+        x0, y0, z0 = line.p0
+        x1, y1, z1 = line.p1
+        lcolor = color
+        if lcolor == None:
+            lcolor = line.color
+        pygame.draw.line( screen, lcolor, (x0, y0), (x1, y1) ) #< Line from P0 to P1
+
+def clearScreen(screen, color=(255,255,255)) -> None:
+  screen.fill(color)
+    
+def newScreen(title="New", resX=SCREEN_WIDTH, resY=SCREEN_HEIGHT, color=WHITE):
+    screenSize = (resX, resY)
+    screen = pygame.display.set_mode( screenSize )
+    clearScreen(screen, color)
+    pygame.display.set_caption(title)
+    return screen
+    
+if __name__ == "__main__":
+    ### 1. Build the ground
+    net    = Object(obj=Objects.net(25,20), color=(0,100,0), name="NET")\
+             .setCenter(pos=(0,0,0), rotate=(PI/2, 0, 0), scale=0.2 )
+    axis1 = Object(filename="./objects/axis.json", color=(10,10,10), name="WorldAxis" )\
+       .scale(100.0)\
+       .setOrigin()
+    ground = Assembly(objects=(net, axis1), name="Ground").translate(-200, 0, 0).setOrigin()    
+
+    ### 2. Build the sun
+    sun = Object(obj=Objects.sphere(500, 15, color=(225,220,50)), name="SUN")
+    sun.setCenter(scale=0.15, rotate=(PI/2,0,0))
+    sun.translate(0, 250, 300)  #< More up (Y) and forward (Z) to the center of the net 
+    sun.setOrigin()
+
+    ### 3. Build the plane
+    axis2  = Object(
+       filename="./objects/axis.json", color=(10,10,10 ))\
+       .scale(100.0)\
+       .setOrigin()
+    f16  = Object(filename="./objects/F16.stl", color=(0,0,255), name="F16")\
+              .setCenter(scale=1.0, rotate=(0,-PI/2,0), method="arithCenter")
+    plane  = Assembly(objects=[f16, axis2], name="Plane")\
+             .rotate(0.5*-3.14/2,0,0)\
+             .translate(0,250,0)\
+             .setOrigin()
+
+    ### 4. Build the world
+    world  = Assembly(objects = (
+        ground,
+        plane,
+        sun,
+        ), name="World")
+
+    pygame.init()
+    clock = pygame.time.Clock()
+    screen = newScreen("3D Wire Frame Shapes", SCREEN_WIDTH, SCREEN_HEIGHT, WHITE)
+    wireframe = DISP.WireFrame(screen, pygame.draw.line, f=50, scale=10.0)
+
+    fps = 30
+    dt = 1/fps
+    t = 0.0
+    camAngX_r = 0.0
+    camAngY_r = 0.0
+    f16Ang_r  = 0.0
+    useMouse = True
+    
+    run = True
+    while run:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+              run = False
+
+        world.reset()
+        #world.rotate(x=1.8,y=3.14,z=0.3)
+        world.rotate(x=camAngX_r,y=camAngY_r,z=0)
+        #world.rotate(x=camAngX_r,y=camAngY_r,z=0)
+        f16.rotate(0, f16Ang_r, 0)
+        world.translate(x=0,y=0,z=-1000)
+
+        ### Draw 3D world
+        clearScreen(screen, WHITE)
+        wireframe.draw(world)
+        
+        ### Wait for next step time
+        if useMouse:
+            (mPosX, mPosY) = pygame.mouse.get_pos()
+            camAngY_r = 0.01*(mPosX -SCREEN_WIDTH/2)
+            camAngX_r = 0.01*(mPosY -SCREEN_HEIGHT/2)
+        else:
+            camAngX_r += 0.5*dt
+            camAngY_r += 1*dt
+        f16Ang_r += 4*dt
+        t += dt
+        clock.tick(30)
+        
+        ### Display output
+        pygame.display.flip()
+
+    pygame.quit()

GSOF_3dWireFrame/F16_Class.py

@@ -0,0 +1,163 @@
+#!/usr/bin/python
+"""
+ * F16_Class.py
+ * Created on: 6 Jan 2025
+ * Improved for: 25 May 2026
+ * Author: Guy Soffer
+ * Copyright (C) 2026 Guy Soffer
+"""
+
+from math import pi
+try:
+   from GSOF_3dWireFrame.Lib3D.Object_WireFrame import Object_wireFrame as Object
+   from GSOF_3dWireFrame.Lib3D.Object_base import Object_base
+   from GSOF_3dWireFrame.Lib3D.Assembly import Assembly
+   from GSOF_3dWireFrame.Lib3D import Objects
+   _3D_active = True
+except:
+   _3D_active = False
+   print("GSOF_Wireframe3D module isn't installed")
+
+degToRad = pi/180
+#YELLOW = (255,255,140)
+YELLOW = (125,125,0)
+BLACK  = (0,0,0)
+RED    = (255,0,0)
+GREEN  = (0,170,0)
+BLUE   = (0,0,255)
+GRAY   = (50,50,50)
+
+class State():
+    def __init__(self,
+                 azimuth_d=0,
+                 pitch_d=0,
+                 roll_d=0,
+                 thrust_lbf=0,
+                 wowNose_b=False,
+                 wowLeft_b=False,
+                 wowRight_b=False):
+        self.azimuth_d = azimuth_d
+        self.pitch_d   = pitch_d
+        self.roll_d    = roll_d
+        self.thrust_lbf = thrust_lbf
+        self.wowNose_b  = wowNose_b
+        self.wowLeft_b  = wowLeft_b
+        self.wowRight_b = wowRight_b
+
+class Commands():
+    def __init__(self,
+                 leftAliron_d=0, rightAliron_d=0,
+                 leftElevator_d=0, rightElevator_d=0,
+                 rudder_d=0, speedbrake_d=0,
+                 throttle=0,
+                 gearsDown_b=True):
+        self.leftAliron_d    = leftAliron_d
+        self.rightAliron_d   = rightAliron_d
+        self.leftElevator_d  = leftElevator_d
+        self.rightElevator_d = rightElevator_d
+        self.rudder_d        = rudder_d
+        self.speedbrake_d    = speedbrake_d
+        self.gearsDown_b     = gearsDown_b
+
+class F16_View(Assembly):
+    """Constructs the gauges screen"""
+    def __init__(self, folder='./'):
+        self.time = 0.0
+        axis  = Object(
+           filename="%s/objects/axis.json"%folder, color=GREEN)\
+           .scale(50.0)\
+           .translate(0, 0, 150)\
+           .setOrigin()
+
+        self.plane = Object(
+            filename="%s/objects/f16.stl"%folder, color=BLUE, name="F16")\
+            .setCenter(scale=1.0, method="arithCenter")
+        
+        self.plume = objects=Object(
+           filename="%s/objects/Plume.json"%folder, color=RED)\
+           .setCenter(scale=30, rotate=(180*degToRad, 0, 0))
+        plume = Assembly(objects=(self.plume,))   
+        plume.translate(0, 0, -90).setOrigin()
+        
+        self.nw = Object(
+           filename="%s/objects/LandingGear.json"%folder, color=BLACK, name="NW")
+        self.nwow = Object(
+           filename="%s/objects/Spark.json"%folder, color=YELLOW, name="NWOW")
+        nw = Assembly(objects=(self.nw, self.nwow), name="NW-Assy")\
+           .translate(0, -2, 0).scale(8).translate(0, -30, 80).setOrigin()           
+
+        self.lw = Object(
+           filename="%s/objects/LandingGear.json"%folder, color=BLACK, name="LW")
+        self.lwow = Object(
+           filename="%s/objects/Spark.json"%folder, color=YELLOW)
+        lw = Assembly(objects=(self.lw, self.lwow), name="LW-Assy")\
+           .translate(0, -2, 0).rotate(x=0, y=0, z=degToRad*15)\
+           .scale(8).translate(18, -30, 0).setOrigin()           
+
+        self.rw = Object(
+           filename="%s/objects/LandingGear.json"%folder, color=BLACK, name="RW")
+        self.rwow = Object(
+           filename="%s/objects/Spark.json"%folder, color=YELLOW)
+        rw = Assembly(objects=(self.rw, self.rwow), name="RW-Assy")\
+           .translate(0, -2, 0).rotate(x=0, y=0, z=-degToRad*15)\
+           .scale(8).translate(-18, -30, 0).setOrigin()           
+
+        self.gears = Assembly(objects=(nw,
+                                       rw,
+                                       lw
+                                       ))
+        super().__init__(objects=(axis, self.plane, plume, self.gears))
+
+    def setControls(self, time, commands=None, state=None):
+        """Update all elements"""
+        self.time += 0.1
+
+        if state != None:
+            self.setWOW(state.wowNose_b, state.wowLeft_b, state.wowRight_b)
+            self.setExahustPlume(state.thrust_lbf)
+            heading =  state.azimuth_d*degToRad
+            pitch   = -state.pitch_d*degToRad
+            roll    =  state.roll_d*degToRad
+            self.setAttitude(heading, pitch, roll)
+
+        if commands != None:
+            self.setFCS(commands.leftAliron_d,
+                        commands.rightAliron_d,
+                        commands.leftElevator_d,
+                        commands.rightElevator_d,
+                        commands.rudder_d,
+                        commands.speedbrake_d)
+            self.setGearsDown(commands.gearsDown_b)
+
+    def setAttitude(self, heading, pitch, roll) -> None:
+        self.rotate( y=-heading, x=-pitch, z=-roll )
+
+    def setExahustPlume(self, thrust_lbf) -> None:
+        thrustMAX = 6360
+        plume = thrust_lbf/thrustMAX
+        if plume > 1:
+            plume = 1
+        elif plume < 0:
+            plume = 0
+        plumeColor = (255, 255*(1-plume), 255*(1-plume))
+        self.plume.rotate(x=0, y=0, z=self.time*plume)
+        self.plume.scale(plume).color = plumeColor
+       
+    def setFCS(self, lAliron_deg, rAliron_deg, lElevator, rElevator, rudder_deg, sb_deg) -> None:
+        return
+      
+    def setGearsDown(self, downCmd) -> None:
+        if downCmd == False:
+           self.gears.scale(0.0)
+        else:
+           self.gears.scale(1.0)
+
+    def setWOW(self, nose, left, right) -> None:
+        time = int(self.time*10)
+        blink = bool(time&0b010)
+        self.nwow.rotate(x=0, y=0, z=4*self.time)\
+                 .scale(int(nose and blink))
+        self.lwow.rotate(x=0, y=0, z=4*self.time)\
+                 .scale(int(left and blink))
+        self.rwow.rotate(x=0, y=0, z=4*self.time)\
+                 .scale(int(right and blink))

GSOF_3dWireFrame/Lib3D/Assembly.py

@@ -0,0 +1,72 @@
+from GSOF_3dWireFrame.Lib3D import Lib3D as L
+from GSOF_3dWireFrame.Lib3D.Object_base import Object_base
+
+
+class Assembly(Object_base):
+    ASSY_NUM = 0
+    """A new frame of reference with collection of other assemblies or objects"""
+    def __init__(self,
+                 objects=[],     #< Objects in assembly  
+                 connections=[], #< Connections between objects (for flexable objects)
+                 name=None
+                 ):
+        self.objects = objects
+        self.connections = connections
+        if name == None:
+            name = "A" +str(Assembly.ASSY_NUM)
+            Assembly.ASSY_NUM += 1
+        self.name = name    
+        super().__init__()
+
+    def reset(self, all=True):
+        """Reset current state and all objects (optional)"""
+        super().reset()
+        if all:
+            for obj in self.objects:
+                obj.reset(all)
+        return self
+
+    def findCenter(self, method) -> list:
+        """Return the center point of the assembly"""
+        points = self.getLines()
+        return super()._findCenter(points, method)
+
+    def getObjects(self) -> list:
+        """Return a list of all objects"""
+        objects = []
+        for obj in self.objects:
+            objects += obj.getObjects()
+        return objects
+
+    def getLines(self):
+        """Return lines of all objects. Will update transformations if needed"""
+        lines = []
+        if not self.isUpdated():
+            self.update()
+
+        ### Lines from all objects 
+        for obj in self.objects:
+            lines += obj.getLines()
+
+        ### Lines between objects 
+        #print("\n", self.name +":") if len(self.connections) > 0 else None
+        for between in self.connections:
+            [obj0, p0], [obj1, p1] = between
+            fromPnt = self.objects[obj0].newPoints[p0]
+            toPnt   = self.objects[obj1].newPoints[p1]
+            lines += [L.Line(fromPnt, toPnt)]
+##            if False:
+##                print("CON: ", obj0, p0, obj1, p1)
+##                print(self.objects[obj0].name, self.objects[obj1].name)
+##                print(fromPnt, toPnt)
+        return lines
+
+    def update(self):
+        """Update the coordinates of all assembly and object"""
+        #print("Update: %s"%self.name)
+        for obj in self.objects:
+            #print("%s.%s"%(self.name,obj.name))
+            if not self.isUpdated():
+                obj.transform(transMatrix=self.state)
+            obj.update()
+        self.stateTouched = False