import pyvista as pv
    import numpy as np
    from PIL import Image
    import requests
    from io import BytesIO
    import cartopy.crs as ccrs
    import cartopy.feature as cfeature
    import matplotlib.pyplot as plt
    import io
    
    class EarthViewer:
        def __init__(self):
            # Download Earth texture
            print("Downloading Earth texture...")
            texture_url = "https://eoimages.gsfc.nasa.gov/images/imagerecords/73000/73909/world.topo.bathy.200412.3x5400x2700.jpg"
            response = requests.get(texture_url)
            self.earth_texture = Image.open(BytesIO(response.content))
            self.texture_array = np.array(self.earth_texture)
            
            # Create sphere with manual vertex duplication for seamless texture
            print("Creating Earth sphere with seamless texture...")
            self.sphere = self.create_seamless_sphere()
            
            # Set up the plotter
            print("Setting up visualization...")
            self.plotter = pv.Plotter()
            self.plotter.background_color = 'black'
            
            # Add the textured sphere
            self.plotter.add_mesh(
                self.sphere,
                texture=self.texture_array,
                smooth_shading=True,
                show_edges=False,
            )
            
            # Set up camera
            self.plotter.camera_position = 'xz'
            self.plotter.enable_point_picking(callback=self.point_clicked, show_message=False)
            
            print("Setup complete!")
    
        def create_seamless_sphere(self, radius=1, phi_resolution=100, theta_resolution=200):
            """Manuel yaklaşım - vertex duplication ile seam düzeltme"""
            print("Creating sphere with manual texture coordinates...")
            
            # Yüksek çözünürlüklü sphere
            phi_res = phi_resolution
            theta_res = theta_resolution
            
            # Açıları hesapla
            phi = np.linspace(0, np.pi, phi_res)
            theta = np.linspace(0, 2*np.pi, theta_res + 1)  # +1 for duplication
            
            # Mesh grid
            phi_grid, theta_grid = np.meshgrid(phi, theta, indexing='ij')
            
            # Spherical to Cartesian
            x = radius * np.sin(phi_grid) * np.cos(theta_grid)
            y = radius * np.sin(phi_grid) * np.sin(theta_grid)
            z = radius * np.cos(phi_grid)
            
            # Flatten arrays
            points = np.column_stack((x.flatten(), y.flatten(), z.flatten()))
            
            # Texture coordinates - directly from spherical angles
            u = theta_grid / (2*np.pi)
            v = 1.0 - (phi_grid / np.pi)
            
            texture_coords = np.column_stack((u.flatten(), v.flatten()))
            
            # Create faces (quads)
            faces = []
            for i in range(phi_res - 1):
                for j in range(theta_res):
                    # Quad vertices
                    v1 = i * (theta_res + 1) + j
                    v2 = i * (theta_res + 1) + (j + 1)
                    v3 = (i + 1) * (theta_res + 1) + (j + 1)
                    v4 = (i + 1) * (theta_res + 1) + j
                    
                    # Two triangles per quad
                    faces.extend([3, v1, v2, v3])
                    faces.extend([3, v1, v3, v4])
            
            # Create PyVista mesh
            sphere = pv.PolyData(points, faces)
            sphere.active_texture_coordinates = texture_coords
            
            print("Manual sphere created with vertex duplication")
            return sphere
    
        def create_map_projection(self, center_lat, center_lon):
            """Create appropriate map projection based on clicked location"""
            fig = plt.figure(figsize=(20, 10))
            
            # First subplot: Orthographic view
            ax1 = plt.subplot(121, projection=ccrs.Orthographic(center_lon, center_lat))
            ax1.add_feature(cfeature.COASTLINE, linewidth=0.5)
            ax1.add_feature(cfeature.BORDERS, linewidth=0.5)
            ax1.add_feature(cfeature.LAND, color='lightgray')
            ax1.add_feature(cfeature.OCEAN, color='lightblue')
            ax1.stock_img()
            ax1.gridlines(color='gray', alpha=0.5, linestyle='--')
            ax1.plot([center_lon], [center_lat], 'ro', transform=ccrs.PlateCarree(), 
                    markersize=10, label='Selected Point')
            ax1.set_title(f'Orthographic View\nCentered at {center_lat:.1f}°N, {center_lon:.1f}°E')
            
            # Second subplot: Create rotated Lambert Cylindrical projection
            rotated_pole = ccrs.RotatedPole(
                pole_longitude=center_lon + 180,
                pole_latitude=-center_lat,
                central_rotated_longitude=0
            )
            
            ax2 = plt.subplot(122, projection=rotated_pole)
            
            # Add map features with explicit transform
            ax2.add_feature(cfeature.COASTLINE, linewidth=0.5)
            ax2.add_feature(cfeature.BORDERS, linewidth=0.5)
            ax2.add_feature(cfeature.LAND, color='lightgray')
            ax2.add_feature(cfeature.OCEAN, color='lightblue')
            ax2.stock_img()
            
            # Add gridlines with labels
            gl = ax2.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
                              linewidth=0.5, color='gray', alpha=0.5, linestyle='--')
            gl.top_labels = False
            gl.right_labels = False
            
            # Set the extent in the rotated coordinate system
            ax2.set_global()
            
            # Transform the center point to the rotated system and plot it
            ax2.plot([center_lon], [center_lat], 'ro', transform=ccrs.PlateCarree(),
                    markersize=10, label='Selected Point')
            
            # Set title
            ax2.set_title(f'Rotated Lambert Cylindrical Projection\nCentered at {center_lat:.1f}°N, {center_lon:.1f}°E')
            
            # Add legends
            ax1.legend(loc='lower left')
            ax2.legend(loc='lower left')
            
            # Adjust layout
            plt.tight_layout()
            
            # Save to buffer
            buf = io.BytesIO()
            plt.savefig(buf, format='png', dpi=300, bbox_inches='tight', facecolor='black')
            buf.seek(0)
            plt.close()
            
            # Show the map
            img = Image.open(buf)
            img.show()
            
        def show(self):
            """Display the interactive globe"""
            print("\nEarth Viewer Ready!")
            print("Click anywhere on the globe to see two views:")
            print("1. Orthographic projection centered on clicked point")
            print("2. Cylindrical projection centered on clicked longitude")
            print("Close the window to exit.")
            self.plotter.show()
    
        def cartesian_to_spherical(self, x, y, z):
            """Convert Cartesian coordinates to spherical (lat/lon)"""
            r = np.sqrt(x**2 + y**2 + z**2)
            lat = np.arcsin(z/r) * 180/np.pi
            lon = np.arctan2(y, x) * 180/np.pi
            return lat, lon
    
        def point_clicked(self, point):
            """Handle click events on the globe"""
            try:
                x, y, z = point
                lat, lon = self.cartesian_to_spherical(x, y, z)
                print(f"Clicked at latitude: {lat:.2f}°, longitude: {lon:.2f}°")
                
                # Create projection
                #self.create_map_projection(lat, lon)
                
            except Exception as e:
                print(f"Error handling click: {str(e)}")
    
    if __name__ == "__main__":
        print("Initializing Earth Viewer...")
        try:
            viewer = EarthViewer()
            viewer.show()
        except Exception as e:
            print(f"Error: {str(e)}")
            print("\nTroubleshooting tips:")
            print("1. Make sure all required packages are installed:")
            print("   pip install -r requirements.txt")
            print("2. Try updating PyVista:")
            print("   pip install --upgrade pyvista")
            print("3. Check if your graphics drivers are up to date")