Upload index.html with huggingface_hub

index.html

@@ -0,0 +1,207 @@
+import pygame
+from pygame.locals import *
+from OpenGL.GL import *
+from OpenGL.GLU import *
+import numpy as np
+from scipy import ndimage
+import random
+
+# Simple 3D Earth Viewer with atmosphere, clouds, terrain, and stars
+# Uses PyOpenGL and pygame for rendering
+
+def create_sphere(radius, slices, stacks):
+    vertices = []
+    normals = []
+    texcoords = []
+    indices = []
+
+    for i in range(stacks + 1):
+        V = i / stacks
+        phi = V * np.pi
+
+        for j in range(slices + 1):
+            U = j / slices
+            theta = U * 2 * np.pi
+
+            x = radius * np.sin(phi) * np.cos(theta)
+            y = radius * np.cos(phi)
+            z = radius * np.sin(phi) * np.sin(theta)
+
+            vertices.append([x, y, z])
+            nx, ny, nz = x/radius, y/radius, z/radius
+            normals.append([nx, ny, nz])
+            texcoords.append([U, V])
+
+    for i in range(stacks):
+        for j in range(slices):
+            first = i * (slices + 1) + j
+            second = first + slices + 1
+            indices.append(first)
+            indices.append(second)
+            indices.append(first + 1)
+
+            indices.append(second)
+            indices.append(second + 1)
+            indices.append(first + 1)
+
+    return np.array(vertices), np.array(normals), np.array(texcoords), np.array(indices)
+
+def create_terrain_noise(resolution=64):
+    # Generate procedural terrain (heightmap)
+    noise = np.random.randn(resolution, resolution) * 0.01
+    noise = ndimage.gaussian_filter(noise, sigma=2)
+    return noise
+
+def create_starfield(num_stars=1000):
+    stars = []
+    for _ in range(num_stars):
+        theta = np.random.uniform(0, 2*np.pi)
+        phi = np.arccos(1 - np.random.uniform(0, 1))
+        r = 100 + np.random.uniform(0, 10)
+        x = r * np.sin(phi) * np.cos(theta)
+        y = r * np.cos(phi)
+        z = r * np.sin(phi) * np.sin(theta)
+        stars.append([x, y, z])
+    return np.array(stars)
+
+def load_texture_from_solid_color(color, width=64, height=64):
+    texture_data = np.zeros((height, width, 3), dtype=np.uint8)
+    texture_data[:, :] = color
+    texture_data = texture_data.tobytes()
+    
+    texture_id = glGenTextures(1)
+    glBindTexture(GL_TEXTURE_2D, texture_id)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, texture_data)
+    return texture_id
+
+def load_simple_earth_texture():
+    # Create a simple blue marble-like texture
+    width, height = 1024, 512
+    texture_data = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    for y in range(height):
+        for x in range(width):
+            # Simple Earth approximation with blue oceans and green/brown continents
+            u, v = x / width, y / height
+            if np.sin(2*np.pi*u) * np.sin(np.pi*v) > 0.5 or (u-0.3)**2 + (v-0.5)**2 < 0.02:
+                texture_data[y, x] = [30, 100, 200]  # Ocean
+            elif np.random.rand() < 0.3:
+                texture_data[y, x] = [100, 180, 80]  # Land
+            else:
+                texture_data[y, x] = [30, 100, 200]
+                
+    texture_data = texture_data.tobytes()
+    texture_id = glGenTextures(1)
+    glBindTexture(GL_TEXTURE_2D, texture_id)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, texture_data)
+    return texture_id
+
+class Earth3DViewer:
+    def __init__(self):
+        pygame.init()
+        self.display = (800, 600)
+        pygame.display.set_mode(self.display, DOUBLEBUF | OPENGL)
+        pygame.display.set_caption("3D Earth Viewer")
+        
+        gluPerspective(45, (self.display[0]/self.display[1]), 0.1, 100.0)
+        glTranslatef(0.0, 0.0, -15)
+        
+        # Create Earth
+        self.vertices, self.normals, self.texcoords, self.indices = create_sphere(6.0, 32, 32)
+        self.cloud_vertices, _, _, _ = create_sphere(6.05, 32, 32)  # Slightly bigger for cloud layer
+        self.atmosphere_vertices, _, _, _ = create_sphere(6.2, 32, 32)  # Atmosphere glow
+        
+        # Load textures
+        self.earth_texture = load_simple_earth_texture()
+        self.cloud_texture = load_texture_from_solid_color([200, 200, 255], 64, 64)
+        self.atmosphere_texture = load_texture_from_solid_color([150, 200, 255, 100], 64, 64)
+        
+        # Create procedural terrain displacement (conceptual)
+        self.terrain_noise = create_terrain_noise(32)
+        
+        # Stars
+        self.stars = create_starfield(500)
+        
+        self.rotation = 0
+        self.cloud_rotation = 0
+        
+    def draw_sphere(self, vertices, texture_id, blend=False, alpha=1.0):
+        if blend:
+            glEnable(GL_BLEND)
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+            glDepthMask(GL_FALSE)
+            
+        glBindTexture(GL_TEXTURE_2D, texture_id)
+        glEnable(GL_TEXTURE_2D)
+        
+        glBegin(GL_TRIANGLES)
+        for i in range(0, len(self.indices), 3):
+            for j in range(3):
+                idx = self.indices[i + j]
+                glTexCoord2fv(self.texcoords[idx])
+                glVertex3fv(vertices[idx])
+        glEnd()
+        
+        glDisable(GL_TEXTURE_2D)
+        if blend:
+            glDisable(GL_BLEND)
+            glDepthMask(GL_TRUE)
+    
+    def draw_stars(self):
+        glEnable(GL_POINT_SMOOTH)
+        glPointSize(1.0)
+        glColor3f(1, 1, 1)
+        glBegin(GL_POINTS)
+        for star in self.stars:
+            glVertex3fv(star)
+        glEnd()
+        
+    def render(self):
+        while True:
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    pygame.quit()
+                    return
+
+            # Handle rotation
+            self.rotation += 0.5
+            self.cloud_rotation += 0.6
+
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+            glEnable(GL_DEPTH_TEST)
+
+            # Draw stars (background)
+            glPushMatrix()
+            glRotatef(self.rotation * 0.01, 0, 1, 0)
+            self.draw_stars()
+            glPopMatrix()
+
+            # Draw Earth
+            glPushMatrix()
+            glRotatef(self.rotation, 0, 1, 0)
+            self.draw_sphere(self.vertices, self.earth_texture)
+            glPopMatrix()
+
+            # Draw clouds
+            glPushMatrix()
+            glRotatef(self.cloud_rotation, 0, 1, 0)
+            self.draw_sphere(self.cloud_vertices, self.cloud_texture, blend=True, alpha=0.3)
+            glPopMatrix()
+
+            # Draw atmosphere glow
+            glPushMatrix()
+            glRotatef(self.rotation, 0, 1, 0)
+            glColor4f(0.5, 0.8, 1.0, 0.1)
+            self.draw_sphere(self.atmosphere_vertices, self.atmosphere_texture, blend=True, alpha=0.1)
+            glPopMatrix()
+
+            pygame.display.flip()
+            pygame.time.wait(30)
+
+if __name__ == "__main__":
+    app = Earth3DViewer()
+    app.render()