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

GSOF_3dWireFrame/Lib3D/Lib3D.py

@@ -0,0 +1,145 @@
+from GSOF_3dWireFrame.MathLib import MathLib as ML
+import json
+from GSOF_3dWireFrame.Lib3D import stlToObj
+
+def loadStl(filename, faceCount=500):
+    return stlToObj.stlToObj(filename, faceCount=faceCount)
+
+def loadJson(filename):
+    obj = None
+    with open(filename) as f:
+        obj = json.load(f)
+    return obj
+
+def dataToDict(points, lines, scale=1.0, color=(0,0,0)):
+    return({"scale":scale,
+            "color":color,
+                  "points_xyz": points,
+                  "connections": lines})
+
+def findArithmeticCenter(points):
+    """ Return the arithmetic center from the list of points """
+    mean = [0]*(len(points[0]))
+
+    for axis in points:
+        for i in range(len(axis)):
+            mean[i]+=axis[i]
+    for i in range(len(mean)):
+        mean[i] = mean[i]/len(points)
+    return mean
+
+def findMinMaxCenter(points):
+    """ Return the center point between the minimum and maximum
+        values in the list of points """
+    Max = 999999
+    Min = -Max
+    N = len(points[0])
+    minPoint = [Max]*N
+    maxPoint = [Min]*N
+    for point in points:
+        for i, v in enumerate(point):
+            if v < minPoint[i]:
+                minPoint[i] = v
+            if v > maxPoint[i]:
+                maxPoint[i] = v
+
+    meanPoint = [0,0,0]
+    for i in range(N):
+        meanPoint[i] = (minPoint[i]+maxPoint[i])/2
+    return meanPoint
+
+def scalePoint(point, scale, dim) -> list:
+    new = [0]*dim
+    for i in range(0, dim):
+        new[i] = point[i]*scale[i]
+    return new
+        
+def scale(points, _scale) -> list:
+    """Scale coordinates"""
+    dim = len(points[0])
+    if not isinstance(_scale, (tuple,list)):
+        _scale = (_scale,)*dim
+    newPoints = [None]*len(points)
+    for i, point in enumerate(points):
+        newPoints[i] = scalePoint(point, _scale, dim)
+    return newPoints
+
+def getRotationMatrix(x=0, y=0, z=0) -> list:
+    """Return the proper rotation matrix for our coordinate system"""
+    return ML.DCM_YXZ(y, x, z) #< the proper rotation order for our coordinate system
+
+def getTransformMatrix(scale=(1,1,1), rotate=(0,0,0), translate=(0,0,0)) -> list:
+    """Return the transformation matrix"""
+    M = getRotationMatrix(*rotate)
+    scaleM = ML.I(3)
+    scaleM[0][0] = scale[0]
+    scaleM[1][1] = scale[1]
+    scaleM[2][2] = scale[2]
+    M = ML.MxM(M, scaleM)
+    M[0] += [translate[0]] #< Add translation
+    M[1] += [translate[1]]
+    M[2] += [translate[2]]
+    return M +[[0,0,0,1]]    #< Add last row and return
+
+def updateTransformationMatrix(oldT, newT) -> list:
+    return ML.MxM(newT, oldT)
+    
+def rotate(points, x=0, y=0, z=0, dcm=None) -> list:
+    newPoints = [None]*len(points)
+    if dcm == None:
+        dcm = getRotationMatrix(x, y, z)
+
+    for i, point in enumerate(points):
+        newPoints[i] = ML.MxV(dcm, point)
+    return newPoints
+
+def translate(points, x=0, y=0, z=0) -> list:
+    newPoints = [None]*len(points)
+    T = [x, y, z]
+    for i, point in enumerate(points):
+        newPoints[i] = ML.addV(point, T)
+    return newPoints
+
+def transform(points, _scale=(1,1,1), _rotate=(0,0,0), _translate=(0,0,0), M=None) -> list:
+    if M == None:
+        M = getTransformMatrix(_scale, _rotate, _translate)
+    return _update(points, M)
+##    points = scale(points, _scale) #< Inefficient method
+##    points = rotate(points, *_rotate)
+##    return translate(points, *_translate)
+
+def _update(points, transformation) -> list:
+    newPoints = [None]*len(points)
+    for i, point in enumerate(points):
+        if len(point) < 4:
+            point += [1] #< Add translation dimension
+        newPoints[i] = (ML.MxV(transformation, point))[0:3]
+    return newPoints
+
+def calcLines(points, connections, color=(0,0,0)) -> list:
+    lines = [None]*len(connections)
+    for i, connect in enumerate(connections):
+        fromPnt, toPnt = connect
+        p0 = points[fromPnt]
+        p1 = points[toPnt]
+        lines[i] = Line(p0, p1, color)
+    return lines
+
+class Line():
+    def __init__(self, p0=None, p1=None, color=(0,0,0)):
+        self.points = [p0, p1]
+        self.color = color
+### THE METHODS BELOW ARE NOT USED
+##    def scale(self, scale):
+##        self.points = scale(self.points, scale)
+##
+##    def translate(self, x=0, y=0, z=0):
+##        self.points = translate(self.points, x,y,z)
+##    
+##    def rotate(self, x=0, y=0, z=0, dcm=None):
+##        self.points = rotate(self.points, x,y,z,dcm)
+
+class Triangle(Line):
+    def __init__(self, p0=None, p1=None, p2=None, color=(0,0,0)):
+        super().__init__(p0, p1, color)
+        self.points += [p2]

GSOF_3dWireFrame/Lib3D/Object_WireFrame.py

@@ -0,0 +1,66 @@
+from GSOF_3dWireFrame.Lib3D import Lib3D as L
+from GSOF_3dWireFrame.Lib3D.Object_base import *
+
+class Object_wireFrame(Object_base):
+    OBJ_NUM = 0
+    def __init__(self, obj=None, filename=None, color=None, name=None):
+        if name == None:
+            name = "O" +str(Object_wireFrame.OBJ_NUM)
+            Object_wireFrame.OBJ_NUM += 1
+        self.name = name    
+        super().__init__()
+        if filename != None:
+            ext = filename.split(".")[-1]
+            if ext == "json":
+                obj = L.loadJson(filename)
+            elif ext == "stl":
+                obj = L.loadStl(filename)
+
+        if color == None:
+            if "color" in obj:
+                color = obj["color"]  #< Color from file
+            else:
+                color = (0,0,0)       #< Default color black
+        self.color       = color               #< Color to draw all lines
+        self.points      = obj["points_xyz"]   #< xyz-coordinates of all corner-points of object
+        self.connections = obj["connections"]  #< Lines between corner points of object
+    
+    def update(self) -> None:
+        self.newPoints = L.transform(points=self.points, M=self.state)
+        self.stateTouched = True
+
+    def getLines(self) -> list:
+        if not self.isUpdated():
+            self.update()
+        return L.calcLines(self.newPoints, self.connections, self.color)
+
+    def setCenter(self,
+                  pos=(0,0,0),
+                  rotate=(0,0,0),
+                  scale=(1,1,1),
+                  method=None
+                  ):
+        """Move all original points to the new location than rotate and scale"""
+        ### Find new center and translate all points
+        center = super()._findCenter(self.points, method)
+        translate = (-(pos[0]+center[0]), -(pos[1]+center[1]), -(pos[2]+center[2]))
+        if True:
+            self.points = L.translate(self.points, *translate)
+            self.points = L.rotate(self.points, *rotate)
+            self.points = L.scale(self.points, scale)
+        else:    
+            transMatrix = L.getTransformMatrix(scale=(1,1,1),
+                                               rotate=(0,0,0),
+                                               translate=translate)
+            self.points = L.transform(points=self.points, M=transMatrix)
+
+            ### Rotate all points
+            if not isinstance(scale, (list, tuple)):
+                scale = (scale,)*3
+            transMatrix = L.getTransformMatrix(scale,
+                                               rotate,
+                                               translate=(0,0,0))
+            self.points = L.transform(points=self.points, M=transMatrix)
+
+        self.stateTouched = True
+        return self

GSOF_3dWireFrame/Lib3D/Object_base.py

@@ -0,0 +1,122 @@
+import copy
+from GSOF_3dWireFrame.MathLib import MathLib as ML
+from GSOF_3dWireFrame.Lib3D import Lib3D as L
+
+class Object_base():
+    def __init__(self):
+        self.stateOrigin = ML.I(4) #< 4x4 matrix to store the original state of scale, rotation and translations
+        self.reset()               #< 4x4 matrix to store the correct state
+
+    def reset(self, all=True):
+        """Reset current state to original"""
+        self.state = self.getOrigin() #< 4x4 matrix to store the correct state
+        self.stateTouched = True
+        return self
+
+    def setOrigin(self, newState=None):
+        """Set current state as the new original state"""
+        if newState == None:
+            newState = self.state
+        self.stateOrigin = copy.deepcopy(newState)
+        return self
+    
+    def getOrigin(self) -> list:
+        """Get the original state"""
+        return copy.deepcopy(self.stateOrigin)
+
+    def _findCenter(self,
+                    points: list|tuple,
+                    method: str="arithCenter"
+                    ) -> list:
+        """Return the center point of all points"""
+        if method == "arithCenter":
+            return L.findArithmeticCenter(points)
+            
+        elif method == "minMaxCenter":
+            return L.findMinMaxCenter(points)
+
+        elif method == None:
+            return (0,0,0)
+        
+        else:
+            return None
+
+    def scale(self, scale: list|tuple|float):
+        """Apply scaling to current state"""
+        """Apply scaling to current state"""
+        if not isinstance(scale, (list, tuple)):
+            scale = (scale,)*3
+        scaleM = ML.I(4)
+        scaleM[0][0] = scale[0]
+        scaleM[1][1] = scale[1]
+        scaleM[2][2] = scale[2]
+        self.state = ML.MxM(self.state, scaleM)
+        self.stateTouched = True
+        return self
+    
+    def copyDcmIntoState(self, dcm: list) -> None:
+        #self.state = ML.copyIntoMatrix(self.state, dcm, rs=0, cs=0)
+        for ri, row in enumerate(dcm):
+            for ci, val in enumerate(row):
+                self.state[ri][ci] = val
+
+    def rotate(self, x: float, y: float, z: float, dcm: list=None, centerAt: list=None):
+        """Apply rotation to current state"""
+        if dcm == None:
+            dcm = L.getRotationMatrix(x, y, z)
+        if centerAt == None:
+            #self.copyDcmIntoState(ML.MxM(self.state[0:3], dcm))
+            dcm[0] += [0]
+            dcm[1] += [0]
+            dcm[2] += [0]
+        else:
+            tx, ty, tz = centerAt[0],centerAt[1],centerAt[2]
+            r = dcm
+            dcm[0] += [tx*(1-r[0][0]) -r[0][1]*ty -r[0][2]*tz]
+            dcm[1] += [ty*(1-r[1][1]) -r[1][0]*tx -r[1][2]*tz]
+            dcm[2] += [tz*(1-r[2][2]) -r[2][0]*tx -r[2][1]*ty]
+        dcm += [[0,0,0,1]]
+        self.state = ML.MxM(dcm, self.state)
+        self.stateTouched = True
+        return self
+
+    def translate(self, x, y, z):
+        """Apply translation to current state"""
+        transM = ML.I(4)
+        transM[0][3] += x
+        transM[1][3] += y
+        transM[2][3] += z
+        self.state = ML.MxM(transM, self.state)
+        self.stateTouched = True
+        return self
+
+    def transform(self,
+                  scale: list=(1,1,1),
+                  rotate: list=(0,0,0),
+                  translate: list=(0,0,0),
+                  transMatrix: list=None
+                  ):
+        """Apply transformation to current state"""
+        if transMatrix == None:
+            self\
+            .scale(scale)\
+            .rotate(*rotate)\
+            .translate(*translate)
+        else:
+            self.state = L.updateTransformationMatrix(self.state, transMatrix)
+        self.stateTouched = True
+        return self
+
+    def isUpdated(self) -> bool:
+        return not bool(self.stateTouched)
+
+    def update(self) -> None:
+        self.stateTouched = False
+
+    def getLines(self) -> list:
+        """Return all lines of object"""
+        return []
+
+    def getObjects(self) -> list: #< For compatibility with Assembly class
+        """Return a list of all objects"""
+        return []

GSOF_3dWireFrame/Lib3D/Objects.py

@@ -0,0 +1,91 @@
+import math
+from GSOF_3dWireFrame.Lib3D import Lib3D as L
+
+LINE_COLOR = (0,0,0)
+
+def net(N=1000, M=1000, dN=100, dM=100, scale=1.0, color=LINE_COLOR) -> dict:
+    points = []
+    lines = []
+    for x in range(N):
+        points.append([0, x*dN, 0])
+        points.append([M*dM, x*dN, 0])
+        
+        lines.append([(x*2), (x*2)+1])
+
+    for y in range(M):
+        points.append([y*dN, 0, 0])
+        points.append([y*dM, N*dN, 0])
+
+        lines.append([N*2+(y*2), N*2+(y*2)+1])
+
+    jsonObject = L.dataToDict(points, lines, scale, color)
+    return jsonObject
+
+def sphere(radius, resolution=10, scale=1.0, color=LINE_COLOR):
+    points = []
+    lines = []
+
+    # Create points
+    for i in range(resolution):
+        theta = i * math.pi / (resolution - 1)
+        for j in range(resolution * 2):
+            phi = j * 2 * math.pi / (resolution * 2)
+            x = radius * math.sin(theta) * math.cos(phi)
+            y = radius * math.sin(theta) * math.sin(phi)
+            z = radius * math.cos(theta)
+            points.append([x, y, z])
+
+    # Create lines
+    for i in range(resolution - 1):
+        for j in range(resolution * 2):
+            p1 = i * resolution * 2 + j
+            p2 = i * resolution * 2 + (j + 1) % (resolution * 2)
+            p3 = ((i + 1) * resolution * 2 + j) % (len(points))
+            p4 = ((i + 1) * resolution * 2 + (j + 1) % (resolution * 2)) % (len(points))
+            lines.extend(((p1, p2), (p1, p3), (p2, p4)))
+
+    # Connect the last row
+    for j in range(resolution * 2):
+        p1 = (resolution - 1) * resolution * 2 + j
+        p2 = (resolution - 1) * resolution * 2 + (j + 1) % (resolution * 2)
+        lines.append((p1, p2))
+
+    return L.dataToDict(points, lines, scale, color)
+
+def rectangle(X, Y, Z, scale=1.0, color=LINE_COLOR):
+    X = 0.5*X
+    Y = 0.5*Y
+    X = 0.5*Z
+
+    points = [
+        [-X, Y,-Z], #<0
+        [ X, Y,-Z], #<1
+        [ X, Y, Z], #<2
+        [-X, Y, Z], #<3
+
+        [-X,-Y,-Z], #<4
+        [ X,-Y,-Z], #<5
+        [ X,-Y, Z], #<6
+        [-X,-Y, Z], #<7
+        ]
+    
+    lines = [[0,1],
+             [1,2],
+             [2,3],
+             [3,0],
+
+             [4,5],
+             [5,6],
+             [6,7],
+             [7,4],
+
+             [0,4],
+             [1,5],
+             [2,6],
+             [3,7],
+             ]
+
+    return L.dataToDict(points, lines, scale, color)
+
+if __name__ == "__main__":
+    print(len(sphere(1000, 25)))

GSOF_3dWireFrame/Lib3D/Utils.py

@@ -0,0 +1,9 @@
+class Colors:
+    WHITE = (255,255,255)
+    BLACK  = (0,0,0)
+    RED    = (255,0,0)
+    GREEN  = (0,170,0)
+    BLUE   = (0,0,255)
+    DARK_BLUE = (220,220,255)
+    YELLOW = (125,125,0)
+    GRAY   = (50,50,50)

GSOF_3dWireFrame/Lib3D/WireFrame_display.py

@@ -0,0 +1,37 @@
+class WireFrame():
+    def __init__(self, screen, line, f=50, scale=1.0):
+        self.screen = screen
+        self.line = line
+        self.f = f
+        self.scale = scale
+        self.centerX, self.centerY = (int(screen.get_width()/2), int(screen.get_height()/2))
+        
+    def draw(self, obj, color=None) -> None:
+        """  """
+        for line in obj.getLines():
+            p0 = self.camera(line.points[0])
+            p1 = self.camera(line.points[1])
+            if (p0[2] > self.f) or (p1[2] > self.f): #Skip lines in the back of the viewer
+                lcolor = color
+                if lcolor == None:
+                    lcolor = line.color
+                self.drawLine( lcolor, p0, p1 ) #< Line from P0 to P1
+
+    def camera(self, point) -> list:
+        """ Perspective projection <https://en.wikipedia.org/wiki/3D_projection> """
+        x, y, z = point
+        z = -z
+        if (self.f != None):
+            if (z > self.f):
+                s = (self.f/z)*self.scale
+            else:
+                s = 100000
+            x *= s
+            y *= s
+        return (x,y,z)
+
+    def drawLine(self, color, p0, p1):
+        """  """
+        p0 = (self.centerX +p0[0], self.centerY -p0[1])
+        p1 = (self.centerX +p1[0], self.centerY -p1[1])
+        self.line( self.screen, color, p0, p1 ) #< Line from P0 to P1

GSOF_3dWireFrame/Lib3D/__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/Lib3D/stlToObj.py

@@ -0,0 +1,40 @@
+from GSOF_3dWireFrame.Lib3D import Lib3D as L
+try:
+    import pymeshlab as ml
+except:
+    print("could not find pymeshlab. DO NOT USE STL FILES!!\nTo install, run ```pip install pymeshlab```")
+
+def stlToObj(filename, faceCount=-1, color=(0,0,0)):
+    # Load the STL file
+    ms = ml.MeshSet()
+    ms.load_new_mesh(filename)
+
+    # Simplify the mesh
+    if faceCount > 0:
+        ms.apply_filter('meshing_decimation_quadric_edge_collapse', 
+                        targetfacenum=faceCount)
+
+    # Get the simplified mesh
+    simplified_mesh = ms.current_mesh()
+    faceMatrix = simplified_mesh.face_matrix()
+    vertexMatrix = simplified_mesh.vertex_matrix()
+
+    # Initialize lists for points and lines
+    points = []
+    lines = []
+
+    for i in range(simplified_mesh.face_number()):
+        # Get the vertices of the triangle
+        vertexes = faceMatrix[i]
+
+        # Add the vertices (points) to the list
+        for vertex in vertexes:
+            points.append(vertexMatrix[vertex].tolist())
+        
+        # Add the edges (lines) to the list
+        lines.append([i*3, i*3+1])
+        lines.append([i*3+1, i*3+2])
+        lines.append([i*3+2, i*3])
+
+    # Now you have a list of points and lines
+    return L.dataToDict(points, lines, scale=100.0, color=color)