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

GSOF_3dWireFrame/MathLib/MathLib.py

@@ -0,0 +1,460 @@
+## By: Guy Soffer (GSOF) 22/Feb/2024
+__version__ = "1.0.0"
+__author__ = "Guy Soffer"
+__copyright__ = ""
+__credits__ = [""]
+__license__ = ""
+__maintainer__ = ""
+__email__ = "gsoffer@yahoo.com"
+__status__ = "Development"
+
+import math, copy
+pi = math.pi
+
+def radToDeg(rad) -> float:
+    """ Convert radians to degrees """
+    return 180*rad/pi # or use this math.degrees(rad)
+
+def modulu(val, modulu):
+    """ Returns the modulus of val%modulu """
+    while val > modulu:
+        val -= modulu
+    while val < -modulu:
+        val += modulu
+    return val
+    
+def clip(val, Min, Max) -> float:
+    """ Return the cliped (clamp) result of the input value """
+    if val < Min:
+        val = Min
+    elif val > Max:
+        val = Max
+    return val
+
+def int_V2(v) -> list:
+    return int(v[0]), int(v[1])
+
+def int_V3(v) -> list:
+    return int(v[0]), int(v[1]), int(v[2])
+
+def intV(v) -> list:
+    out = [0]*len(v)
+    for i, elm in enumerate(v):
+        out[i] = int(elm)
+    return out
+
+def scale_V2(v, s) -> list:
+    return v[0] * s, v[1] * s
+
+def scale_V3(v, s) -> list:
+    return v[0] * s, v[1] * s, v[2] * s
+
+def negR_V2(R) -> list:
+    """ TBR """
+    R[0][1] *= -1
+    R[1][0] *= -1
+    return R
+
+def absV_V2(V) -> float:
+    """ Return the magnitude of 2D vector """
+    return math.sqrt((V[0]**2) +(V[1]**2))
+
+def angle_V2(V) -> float:
+    """ Return the angle of 2D vector """
+    return math.atan2(V[1], V[0])
+
+def polar_V2(V) -> float:
+    """ Return the polar coordinates of 2D vector """
+    return [absV(V), angle_V2(V)]
+
+def rotation_V2(rad, V) -> list:
+    #sinX = math.sin(rad)
+    #cosX = math.cos(rad)
+    #DCM = ((cosX, -sinX), (sinX, cosX))
+    return MxV_2x2(DCM_V2(rad), V)
+    
+def absV_V3(V) -> float:
+    """ Return the magnitude of 2D vector """
+    return math.sqrt((V[0]**2) +(V[1]**2) +(V[2]**2))
+
+def angle_V3(v) -> list:
+    r = absV_V3(v)
+    _absV2 = absV_V2( v[0:2] )
+    elevation = pi / 2.0                          #< For case 0 and 1
+    #elevation = 0.0                                  #< For case2
+    if _absV2 > 0.001:
+        elevation = math.arctan( v[2] / _absV2 )  #< Case1 - https://keisan.casio.com/exec/system/1359533867 (Passed targeting test)
+        #elevation = -math.arctan2( _absV2, v[2]) +pi/2  #< Case2 - https://keisan.casio.com/exec/system/1359533867
+        #elevation = math.arcsin( r / v[2])               #< Case3 - https://www.mechamath.com/trigonometry/cartesian-to-spherical-coordinates-formulas-and-examples/
+    azimuth = math.arctan2(v[1], v[0])
+    return azimuth, elevation, r
+
+def cartesianToPolar_V3(pos):
+    return angle_V3(pos)
+
+def polarToCartesian_V3(azimuth, elevation, distance):
+    abs_xy = distance * math.cos(elevation)
+    x = abs_xy * math.cos(azimuth)
+    y = abs_xy * math.sin(azimuth)
+    z = distance * math.sin(elevation)
+    return x, y, z
+
+def DCM_V2(rad) -> list:
+    """ Return the 2D rotation matrix """
+    cosA = math.cos(rad)
+    sinA = math.sin(rad)
+    return [[cosA,-sinA],[sinA,cosA]]
+
+### https://en.wikipedia.org/wiki/Rotation_matrix
+def DCM_XZY(a, b, c) -> list:
+    """ a is around X, b is around Z, and c is around Y"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+    
+    sa = math.sin(a)
+    sb = math.sin(b)
+    sc = math.sin(c)
+    DCM = [ [    cb*cc,        -sb,         cb*sc    ],
+            [sa*sc+ca*cc*sb,   ca*cb,  ca*sb*sc-cc*sa],
+            [cc*sa*sb-ca*sc,   cb*sa,  ca*sb*sc      ]]
+    return DCM
+
+def get_abc_XZY(dcm) -> list:
+    R32 = dcm[2][1]
+    R11 = dcm[0][0]
+    R12 = dcm[0][1]
+    R13 = dcm[0][2]
+    R22 = dcm[1][1]
+    a = math.atan(R32/R22)
+    b = math.asin(-R12)
+    c = math.atan(R13/R11)
+    return (a,b,c)
+
+def DCM_XYZ(a, b, c) -> list:
+    """ a is around X, b is around Y, and c is around Z"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+    
+    sa = math.sin(a)
+    sb = math.sin(b)
+    sc = math.sin(c)
+    DCM = [ [    cb*cc,           -cb*sc,        sb  ],
+            [ca*sc+sa*sb*cc,  ca*cc-sa*sb*sc,  -sa*cb],
+            [sa*sc-ca*sb*cc,  sa*cc+ca*sb*sc,   ca*cb]]
+    return DCM
+
+def get_abc_XYZ(dcm) -> list:
+    R11 = dcm[0][0]
+    R12 = dcm[0][1]
+    R13 = dcm[0][2]
+    R23 = dcm[1][2]
+    R33 = dcm[2][2]
+    a = math.atan(-R23/R33)
+    b = math.asin(R13)
+    c = math.atan(-R12/R11)
+    return (a,b,c)
+
+def DCM_YXZ(a, b, c) -> list:
+    """ a is around Y, b is around X, and c is around Z"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+    
+    sa = math.sin(a)
+    sb = math.sin(b)
+    sc = math.sin(c)
+    DCM = [ [ca*cc+sa*sb*sc,  cc*sa*sb-ca*sc,   cb*sa],
+            [     cb*sc    ,      cb*cc,          -sb],
+            [ca*sb*sc-cc*sa,  ca*cc*sb+sa*sc,   ca*cb]]
+    return DCM
+
+def get_abc_YXZ(dcm) -> list:
+    R13 = dcm[0][2]
+    R21 = dcm[1][0]
+    R22 = dcm[1][1]
+    R23 = dcm[1][2]
+    R33 = dcm[2][2]
+    a = math.atan(R13/R33)
+    b = math.asin(-R23)
+    c = math.atan(R21/R22)
+    return (a,b,c)
+
+
+def DCM_YZX(a, b, c) -> list:
+    """ a is around Y, b is around Z, and c is around X"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+    
+    sa = math.sin(a)
+    sb = math.sin(b)
+    sc = math.sin(c)
+    DCM = [ [ca*cb  , sa*sc-ca*cc*sb, cc*sa+ca*sb*sc],
+            [  sb   ,     cb*cc,          -cb*sc    ],
+            [-cb*sa , ca*sc+cc*sa*sb, ca*cc-sa*sb*sc]]
+    return DCM
+
+def get_abc_YZX(dcm) -> list:
+    R31 = dcm[2][0]
+    R11 = dcm[0][0]
+    R21 = dcm[1][0]
+    R22 = dcm[1][1]
+    R23 = dcm[1][2]
+    a = math.atan(-R31/R11)
+    b = math.asin(R21)
+    c = math.atan(-R23/R22)
+    return (a,b,c)
+
+def DCM_ZYX(a, b, c) -> list:
+    """ a is around Z, b is around Y, and c is around X"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+
+    p = pi/2
+    sa = math.cos(a -p) #<math.sin(a)
+    sb = math.cos(b -p) #<math.sin(b)
+    sc = math.cos(c -p) #<math.sin(c)
+
+    DCM = [ [ca*cb, ca*sb*sc-cc*sa, sa*sc+ca*sb*cc],
+            [sa*cb, sa*sb*sc+ca*cc, cc*sa*sb-ca*sc],
+            [ -sb,       cb*sc,          cb*cc    ]]
+    return DCM
+
+def get_abc_ZYX(dcm) -> list:
+    R11 = dcm[0][0]
+    R21 = dcm[1][0]
+    R31 = dcm[2][0]
+    R32 = dcm[2][1]
+    R33 = dcm[2][2]
+    a = math.atan(R21/R11)
+    b = math.asin(-R31)
+    c = math.atan(R32/R33)
+    return (a,b,c)
+
+def DCM_ZXY(a, b, c) -> list:
+    """ a is around Z, b is around X, and c is around Y"""
+    ca = math.cos(a)
+    cb = math.cos(b)
+    cc = math.cos(c)
+
+    p = pi/2
+    sa = math.cos(a -p) #<math.sin(a)
+    sb = math.cos(b -p) #<math.sin(b)
+    sc = math.cos(c -p) #<math.sin(c)
+
+    DCM = [ [ca*cb, ca*sb*sc-cc*sa, sa*sc+ca*sb*cc],
+            [sa*cb, sa*sb*sc+ca*cc, cc*sa*sb-ca*sc],
+            [ -sb,       cb*sc,          cb*cc    ]]
+    return DCM
+
+def get_abc_ZXY(dcm) -> list:
+    R12 = dcm[0][1]
+    R22 = dcm[1][1]
+    R31 = dcm[2][0]
+    R32 = dcm[2][1]
+    R33 = dcm[2][2]
+    a = math.atan(-R12/R22)
+    b = math.asin(R32)
+    c = math.atan(-R31/R33)
+    return (a,b,c)
+
+def MxV_2x2(M,V) -> list:
+    """ Return the result of 2x2 matrix and 2D vector multiplication """
+    O = [0,0]
+    O[0] = M[0][0]*V[0] +(M[0][1]*V[1])
+    O[1] = M[1][0]*V[0] +(M[1][1]*V[1])    
+    return O
+
+def MxV(M,V) -> list:
+    """ Return the result of NxM matrix and V vector multiplication """
+    N = len(M)
+    O = [0]*N
+    for r,row in enumerate(M):
+        for m,v in zip(row,V):
+            O[r] += m*v
+    return O
+
+def getCol(M, col) -> list:
+    """ Returns a copy of column 'col' from the matrix 'M' """
+    rows = len(M)
+    V = [0]*rows
+    for i, row in enumerate(M):
+        V[i] = row[col]
+    return V
+
+def getRow(M, row) -> list:
+    """ Returns a copy of row 'row' from the matrix 'M' """
+    return copy.copy(M[row])
+
+def MUL_3x3(M, V):
+    return [ M[0][0]*V[0] +M[0][1]*V[1] +M[0][2]*V[2],
+             M[1][0]*V[0] +M[1][1]*V[1] +M[1][2]*V[2],
+             M[2][0]*V[0] +M[2][1]*V[1] +M[2][2]*V[2] ]
+
+def MUL_4x4(M, V):
+    return [ M[0][0]*V[0] +M[0][1]*V[1] +M[0][2]*V[2] +M[0][3]*V[3],
+             M[1][0]*V[0] +M[1][1]*V[1] +M[1][2]*V[2] +M[1][3]*V[3],
+             M[2][0]*V[0] +M[2][1]*V[1] +M[2][2]*V[2] +M[2][3]*V[3],
+             M[3][0]*V[0] +M[3][1]*V[1] +M[3][2]*V[2] +M[3][3]*V[3] ]
+
+def MxM(M1, M2) -> list:
+    """ Return the result two matrix multiplication """
+    rows = len(M2) #< If vector instead of matrix make a matrix
+    try:
+        colsM2 = len(M2[0])
+    except:
+        M2 = [M2]
+        rows = 1
+
+    try:           #< If vector instead of matrix make a matrix
+        cols = len(M1[0])
+    except:
+        cols = len(M1)
+        M1 = [M1]
+
+    rows = len(M1)    #< Rows in M1
+    cols = len(M2[0]) #< Columns in M2
+    O = zeros(rows, cols) #< The output
+    for r in range(0,rows):
+        row = getRow(M1, r)
+        for c in range(0, cols):
+            col = getCol(M2, c) #< col is a row vector
+            O[r][c] = VxV(row[0:len(col)], col)
+    return O
+
+def add_V2(V1, V2) -> list:
+    """ Return the result of 2D vector addition """
+    return [V1[0]+V2[0], V1[1]+V2[1]]
+
+#def addV(V1, V2) -> list:
+#    out = [0]*len(V1)
+#    for i, elm1, elm2 in enumerate(zip(V1,V2)):
+#        out[i] = elm1+elm2
+#    return out
+
+def addV(V1, V2) -> list:
+    """ Return the result of vector addition """
+    O = [0]*len(V1)
+    i = 0
+    for v1,v2 in zip(V1, V2):
+        O[i] = v1+v2
+        i += 1
+    return O
+
+def absV(V) -> float:
+    """ Return the magnitude of vector """
+    s2 = 0
+    for v in V:
+        s2 += v**2
+    return math.sqrt(s2)
+
+def scaleV(V, s) -> list:
+    """ Return the scaled vector 'V' by the scaler 's' """
+    O = [0]*len(V)
+    for i, e in enumerate(V):
+        O[i] = e*s
+    return O
+
+def VxV(V1, V2) -> float:
+    """ Returns the result of two vector multiplacation """
+    Sum = 0
+    for e1, e2 in zip(V1, V2):
+        Sum += e1*e2
+    return Sum
+
+def matrix(rows, cols, val=0) -> list:
+    """ Returns the rows by cols matrix M filled with value val """
+    M = [0]*rows
+    for row in range(0,rows):
+        M[row] = [val]*cols
+    return M
+
+def zeros(rows, cols) -> list:
+    """ Returns the rows by cols zero matrix Z """
+    return matrix(rows, cols, val=0)
+
+def ones(rows, cols) -> list:
+    """ Returns the rows by cols zero matrix Z """
+    return matrix(rows, cols, val=1)
+
+def I(size) -> list:
+    """ Returns the size by size identity matrix I """
+    I = [0]*size
+    for row in range(0,size):
+        I[row] = [0]*size
+        I[row][row] = 1
+    return I
+    
+def T(M) -> list:
+    """ Returns the transposed Matrix of M """
+    rows = len(M)
+    try:
+        cols = len(M[0])
+    except:
+        cols = rows
+        rows = 1
+        M = [M]
+    O = [0]*cols
+    for i in range(0,cols):
+        O[i] = getCol(M,i)
+    return O
+    
+def invM(M) -> list:
+    """ Not ready yet, Returns the inverse of the matrix M (Using Naive Gauss elimination method) """
+    rows = len(M)
+    cols = rows
+    O = [0]*rows
+    O[0] = copy.copy(M[0]) #scaleV(M[0], 1)
+    for col in range(0, cols-1):
+        stRow = col
+        refRow = M[stRow]
+        for i in range(stRow +1, rows):
+            row = M[i]
+            tmpRow1 = scaleV(refRow, -row[col])
+            tmpRow2 = scaleV(row, refRow[col])
+            O[i] = addV(tmpRow2, tmpRow1)
+        M = copy.copy(O)
+    return O
+
+def LU(M) -> list:
+    """ Not ready yet, Returns the lower and upper (LU) matrixes that forms the matrix M """
+    rows = len(M)
+    cols = rows
+    L = I(rows)
+    U = [0]*rows
+    U[0] = copy.copy(M[0]) #scaleV(M[0], 1)
+    for col in range(0, cols-1):
+        stRow = col
+        refRow = M[stRow]
+        for i in range(stRow +1, rows):
+            row = M[i]
+            tmpRow1 = scaleV(refRow, -row[col])
+            tmpRow2 = scaleV(row, refRow[col])
+            L[i][col] = refRow[col]/row[col]
+            U[i] = addV(tmpRow2, tmpRow1)
+        M = copy.copy(U)
+    return (L, U)
+
+def copyIntoMatrix(M, S, rs=0, cs=0, rn=3, cn=3) -> list:
+    for ri in range(0,rn):
+        row = S[ri]
+        for ci in range(0, cn):
+            M[rs+ri][cs+ci] = row[ci]
+    return M
+
+if __name__ == "__main__":
+#    M = [[1,2,3,4],
+#         [4,5,60,7],
+#         [7,8,9,11],
+#         [17,18,19,10],
+#         ]
+    M = [[1,2,3],
+         [4,5,6],
+         [7,8,11],
+         ]
+
+    #o = invM(M)
+    l,u = LU(M)

GSOF_3dWireFrame/MathLib/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python 
+
+# this is a wrapper module for different platform implementations
+#
+# (C) 2019 Guy Soffer <gsoffer@yahoo.com>
+
+VERSION = '101'

GSOF_3dWireFrame/attitudeViewer.py

@@ -0,0 +1,5 @@
+from modules.AttitudeViewer_class import AttitudeViewer
+
+if __name__ == "__main__":
+    attitude = AttitudeViewer()
+    attitude.start()

GSOF_3dWireFrame/modules/AttitudeViewer_class.py

@@ -0,0 +1,115 @@
+import pygame, math, json
+from Lib3D import Object_WireFrame as OWF
+from Lib3D import Object_base as OB
+from Lib3D import WireFrame_display as DISP
+from Lib3D import Objects
+from modules import Controls
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+WHITE = (255,255,255)
+BLACK = (0,0,0)
+PI = math.pi
+
+def newScreen(title="New", resX=SCREEN_WIDTH, resY=SCREEN_HEIGHT, color=WHITE):
+    screen = pygame.display.set_mode( (resX, resY) )
+    screen.fill(color)
+    pygame.display.set_caption(title)
+    return screen
+ 
+class AttitudeViewer():
+  def __init__(self):
+      net  = OWF.Object_wireFrame(obj=Objects.net(25,25), color=(0,100,0)).rotate(x=PI/2, y=0, z=0).translate(V=(0, 0, 0), initShape=True).scale(0.2, initShape=True)
+      axis = OWF.Object_wireFrame(filename="./objects/axis.json", color=(10,10,10)).translate(V=(0, 0, 0), initShape=True).scale(5.0, initShape=True)
+      self.f16  = OWF.Object_wireFrame(filename="./objects/F16.stl", color=(0,0,255)).translate(V=(0, 0, 0), initShape=True)
+      self.f16.setOrigin( origin=self.f16.getOrigin(origin="arithCenter"), initShape=True ).scale(0.02, initShape=True)
+  #    f16.translate(V=(0, 0, 200), initShape=True)
+  #    f16.rotate(x=0, y=PI/2, z=PI, origin="arithCenter", initShape=True)
+  #    f16.translate(V=(-50, -50, 0), initShape=True)
+
+      self.world = OB.Object_container(objList = (
+          axis,
+          net,
+          self.f16,
+          ))
+
+      pygame.init()
+      self.clock     = pygame.time.Clock()
+      self.screen    = newScreen("3D Wire Frame - Attitude Viewer", SCREEN_WIDTH, SCREEN_HEIGHT, WHITE)
+      self.wireframe = DISP.WireFrame(self.screen, pygame.draw.line, f=50, scale=10)
+      self.viewer    = Controls.Viewer( pos=(0,0,-1200),
+                                        center=(int(self.screen.get_width()/2),int(self.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
+                                       )
+      self.uut       = Controls.Object( pos=(200,200,200),
+                                        center=(int(self.screen.get_width()/2), int(self.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
+                                       )
+
+      self.fps = 30
+      self.dt = 1/self.fps
+      self.t = 0.0
+      self.objects = [self.viewer, self.uut]
+      self.objSel  = 0
+      self.run = False
+
+  def _clearScreen(self, color=(255,255,255)) -> None:
+      self.screen.fill(color)
+
+  def start(self):    
+      self.run = True
+      while self.run:
+          ### Get inputs
+          for event in pygame.event.get():
+              if event.type == pygame.QUIT:
+                self.run = False
+
+          keys = pygame.key.get_pressed()
+          (mPosX, mPosY) = pygame.mouse.get_pos()
+          if keys[pygame.K_v]:
+            self.objSel = 0
+          elif keys[pygame.K_u]:
+            self.objSel = 1
+
+          self.objects[self.objSel].update(keys, mPosX, mPosY, speed=2)
+
+          self.wireframe.f += -(keys[pygame.K_1] - keys[pygame.K_2])*10
+
+          ### Calculate next step state
+  #        t += dt
+
+          ### Update 3D world
+          self.world.reset()
+          self.f16.rotate( *self.uut.getAttitude() ).translate( V=self.uut.getPosition() )
+          self.world.translate( V=self.viewer.getPosition() ).rotate( *self.viewer.getAttitude() )
+
+          ### Draw 3D world
+          self._clearScreen(WHITE)
+          self.wireframe.draw(self.world)
+
+          ### Wait for next step time
+          self.clock.tick(30)
+
+          ### Display output
+          pygame.display.flip()
+          
+      pygame.quit()
+
+if __name__ == "__main__":
+    attitude = AttitudeViewer()
+    attitude.start()
+

GSOF_3dWireFrame/modules/Controls.py

@@ -0,0 +1,60 @@
+import math
+
+class Viewer():
+    def __init__(self, pos=(0,0,0), att=(0,0,0), center=(0,0),
+                 moveLeftKey=0, moveRightKey=0,
+                 moveUpKey=0,   moveDownKey=0,
+                 moveFwdKey=0,  moveBackKey=0,
+                 tiltLeft=0,    tiltRight=0):
+        self.posX = pos[0]
+        self.posY = pos[1]
+        self.posZ = pos[2]
+        self.attX = att[0]
+        self.attY = att[1]
+        self.attZ = att[2]
+        self.centerX = center[0]
+        self.centerY = center[1]
+        self.moveLeftKey  = moveLeftKey
+        self.moveRightKey = moveRightKey
+        self.moveUpKey    = moveUpKey
+        self.moveDownKey  = moveDownKey
+        self.moveFwdKey   = moveFwdKey
+        self.moveBackKey  = moveBackKey
+        self.tiltLeft     = tiltLeft
+        self.tiltRight    = tiltRight
+
+    def update(self, keys, mPosX, mPosY, speed=2) -> list:
+        pos = self.updatePos(keys, mPosX, mPosY, speed)
+        att = self.updateAtt(keys, mPosX, mPosY, speed)
+        return (pos, att)
+
+    def getPosition(self):
+        return (self.posX, self.posY, self.posZ)
+      
+    def getAttitude(self):
+        return (self.attX, self.attY, self.attZ)
+
+    def updateAtt(self, keys, mPosX, mPosY, speed) -> list:
+        self.attY = 0.5*math.pi*(mPosX/self.centerX -1)
+        self.attX = 0.5*math.pi*(mPosY/self.centerY -1)
+        return self.getAttitude()
+
+    def updatePos(self, keys, mPosX, mPosY, speed) -> list:
+        self.posX += -(keys[self.moveRightKey] -keys[self.moveLeftKey])*2.0*speed
+        self.posY += -(keys[self.moveUpKey]    -keys[self.moveDownKey])*2.0*speed
+        self.posZ += -(keys[self.moveBackKey]  -keys[self.moveFwdKey])*5.0*speed
+        return self.getPosition()
+
+class Object(Viewer):
+    def updateAtt(self, keys, mPosX, mPosY, speed) -> list:
+        self.attY = 0.5*math.pi*(mPosX/self.centerX -1)
+        self.attX = 0.5*math.pi*(mPosY/self.centerY -1)
+        speed = 3*math.pi/180 #< 3 deg
+        self.attZ += (keys[self.tiltRight] -keys[self.tiltLeft])*speed
+        return self.getAttitude()
+
+    def updatePos(self, keys, mPosX, mPosY, speed) -> list:
+        self.posX += -(keys[self.moveRightKey] -keys[self.moveLeftKey])*2.0*speed
+        self.posY += -(keys[self.moveUpKey]    -keys[self.moveDownKey])*2.0*speed
+        self.posZ += -(keys[self.moveFwdKey]   -keys[self.moveBackKey])*5.0*speed
+        return self.getPosition()

GSOF_3dWireFrame/modules/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python 
+
+# this is a wrapper module for different platform implementations
+#
+# (C) 2019 Guy Soffer <gsoffer@yahoo.com>
+
+VERSION = '101'

GSOF_3dWireFrame/objects/Axis.json

@@ -0,0 +1,40 @@
+{"scale":100.0,
+ "color":[10,10,10],
+ "points_xyz":[
+               [0, 0, 0],
+               [1, 0, 0],
+               [0, 1, 0],
+               [0, 0, 1],
+
+               [1.05,  0.1, 0.0],
+               [1.25, -0.1, 0.0],
+               [1.25,  0.1, 0.0],
+               [1.05, -0.1, 0.0],
+
+               [-0.1, 1.15, 0.0],
+               [ 0.0, 1.05, 0.0],
+               [ 0.1, 1.15, 0.0],
+               [-0.1, 0.95, 0.0],
+
+               [-0.1,  0.1, 1.05],
+               [ 0.1,  0.1, 1.05],
+               [-0.1, -0.1, 1.05],
+               [ 0.1, -0.1, 1.05]
+              ],
+
+"connections":[
+         [0,1],
+         [0,2],
+         [0,3],
+
+         [4,5],
+         [6,7],
+
+         [8,9],
+         [10,11],
+
+         [12,13],
+         [13,14],
+         [14,15]
+        ]
+}