Q

 ┌───────────────────────────────┐
 │ Touchégg Gesture Setup │
 └───────────────────────────────┘
Step 1: Install Touchégg daemon (system-wide)
─────────────────────────────────────────────
$ wget https://github.com/JoseExposito/touchegg/releases/download/2.0.18/touchegg_2.0.18_amd64.deb
$ sudo apt install ./touchegg_2.0.18_amd64.deb
# ✅ Verifies installation:
$ systemctl status touchegg.service
Step 3: Set up client for GUI auto-start
────────────────────────────────────────
$ mkdir -p ~/.config/autostart
$ cp /etc/xdg/autostart/touchegg.desktop ~/.config/autostart/
# Optional: Enhance the desktop file to auto-verify the daemon:
$ nano ~/.config/autostart/touchegg.desktop

import string

# Define a function to add custom subplot numbering with increasing alphabet letters
def add_subplot_number(ax, font_size=16):
 global subplot_count
 subplot_count += 1
 ax.annotate(f'({string.ascii_lowercase[subplot_count - 1]})', xy=(0, 1), xycoords='axes fraction', fontsize=font_size, xytext=(10, -10), textcoords='offset points', ha='left', va='top')

def fun():
 global subplot_count
 subplot_count = 0
 fig = plt.figure(figsize=figsize, dpi=dpi)
 ax4 = fig.add_axes([width_x*0.5, width_x, parameter_plot_height_ratio])
 add_subplot_number(ax4)

!pip install -y uv
!uv pip install -q condacolab
import condacolab
condacolab.install()

import condacolab
condacolab.check()

!conda install {package_name}
# or, faster:
!mamba install {package_name}

!echo $HOME

%%writefile ~/.netrc
machine urs.earthdata.nasa.gov
 login kroy0001
 password /#j%kWrPA,8.HRe

!chmod 600 ~/.netrc

import time
from multiprocessing.pool import ThreadPool
from google.colab import output
def download_url(url):
 start_time = time.time()
 !curl -O -b ~/.urs_cookies -c ~/.urs_cookies -L -n {url}
 return time.time() - start_time
def download_parallel(urls):
 with ThreadPool(9) as pool: # Using 9 threads (10 CPUs - 1)
 for download_time in pool.imap_unordered(download_url, urls):
 print('time (s):', download_time)
 output.clear()
# Read URLs from file and start parallel download
with open("/content/url.txt", 'r') as file:
 download_parallel(file)

from tqdm import tqdm
from google.colab import output
from multiprocessing.pool import ThreadPool
def download_url(url):
 !wget -q --no-check-certificate -c -P . {url}
 return None
file = open("/content/url.txt", 'r')
urls = [line.strip() for line in file]
list(tqdm(ThreadPool(processes=10).imap(download_url, urls), total=len(urls), desc="Downloading"))
#output.clear() #cleaning the display after downloading completion

!curl --request POST --user kroy0001:/#j%kWrPA,8.HRe --header "Content-Length: 0" "https://appeears.earthdatacloud.nasa.gov/api/login"

from tqdm import tqdm
from google.colab import output
from multiprocessing.pool import ThreadPool
files_location = f'files'
!mkdir files
def download_url(url):
###########################################################################################################################
 !curl -s -L -O --remote-header-name \
 --header "Authorization: Bearer oC0yy-rwxRSG5_9PH-KUpFqhWvtt1OO9pgqBztWYNnF4eZ-9ZMc38nyBSG37Q-5ZF2jQClrLOtsLNPoa6iOu0Q" \
 --location {url} \
 --output-dir {files_location}
###########################################################################################################################
file = open(f'/content/url.txt', 'r')
urls = [line.strip() for line in file]
list(tqdm(ThreadPool(processes=10).imap(download_url, urls), total=len(urls), desc="Downloading"))

!sudo apt-get install gdal-bin

input_raster = '/content/2016_soil_m/SPL4SMGP.006_Geophysical_Data_sm_surface_0_doy2016001_aid0001.tif'
temp_raster = '/content/resampled_raster.tif'
shapefile = '/content/boundaryOutputx.shp'
output_raster = '/content/output.tif'

!gdalwarp \
 -tr 0.001 0.001 \
 -overwrite \
 {input_raster} \
 {temp_raster}

!gdalwarp \
 -cutline {shapefile} \
 -dstnodata 0 \
 -overwrite \
 {temp_raster} \
 {output_raster}

!gdal_translate \
 -of GTiff \
 -a_ullr {left} {top} {right} {bottom} \
 -a_srs EPSG:4326 \
 {png_file} \
 {output_tiff}

=CONCATENATE(REGEXEXTRACT(B2,"[0-9]*.[0-9]{6}"),",",REGEXEXTRACT(C2,"[0-9]*.[0-9]{6}")) 
or
=CONCATENATE(REGEXEXTRACT(TEXT(A2,"00.000000"),"[0-9]*.[0-9]{5}"),":",REGEXEXTRACT(TEXT(B2,"00.000000"),"[0-9]*.[0-9]{5}")) 
>>for 31.4754428611 >> 31.475442 << 6 digits after decimal

from google.colab import drive
drive.mount('/content/drive')

from google.colab.patches import cv2_imshow
import numpy as np 
predicted_image = np.array(v7[:,:,2], dtype=np.float32) # This would be your image array
cv2img = cv2_imshow(predicted_image) # This work the same as passing an image

import cv2
from google.colab.patches import cv2_imshow
import numpy as onp
image_array
img = onp.array(image_array)
cv2_imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

INPUT_FILES = 'input1'
OUTPUT_FILES = 'output1'
!mkdir -p {INPUT_FILES}
!mkdir -p {OUTPUT_FILES}

%%writefile goDeleteHolistic.js
'use strict';
const fs = require('fs');
let d=0;
let darray1 = fs.readdirSync({INPUT_FILES});
let darray2 = fs.readdirSync({OUTPUT_FILES});
for (let index = 0; index < darray1.length; index++) {
 console.log(index)
 if (darray2.includes(darray1[index])) {
 console.log(d++)
 
 fs.unlinkSync({INPUT_FILES}+darray1[index])
 }
}
 
####################################node execution
!node goDeleteHolistic.js

!ffmpeg -y -hwaccel cuvid \
 -i '/content/test.mp4' \
 -r 24 {INPUT_FILES}/out_%09d.png

#####################################create video 1
!ffmpeg \
-framerate 24 \
-pattern_type glob \
-i {INPUT_FILES}'/*.png' \
input0.mp4
#####################################create vodeo 2
!ffmpeg \
-framerate 24 \
-pattern_type glob \
-i {OUTPUT_FILES}'/*.png' \
input1.mp4
#####################################merge video 1 and video 2
!ffmpeg \
-i input0.mp4 -i input1.mp4 \
-filter_complex \
"[0:v][1:v]vstack=inputs=2" \
finalOutput.mp4
#####################################add sound of main video to final output video
!ffmpeg \
-i 'finalOutput.mp4' -i 'm.mp4' \
-c:v copy -c:a copy -map 0:v:0 -map 1:a:0 \
OUTPUT_FILE.mp4

from google.colab import output
output.clear()

from IPython.display import clear_output
clear_output()

import cv2
from google.colab.patches import cv2_imshow
import numpy as np 
def show_image(argu):
 L1 = argu[0]
 predicted_image = np.array(argu[0], dtype=np.uint8).reshape(newsize) # This would be your image array
 a = predicted_image
 for i in range(0,argu.shape[0]):
 predicted_image = np.array(argu[i], dtype=np.uint8).reshape(newsize) 
 a = cv2.hconcat([a, predicted_image])
 cv2_imshow(a)
show_image(metrics['logits'])

!zip -r /content/output.zip /content/folder

from google.colab import files
files.download("/content/output.zip")

!zip -q -j -r folder.zip . -i content/{files_location}/*.tif #folder `.zip` will be created at current location with expensions `*.tif`

!unzip /content/archive.zip #unzipping the flower images from archive..

%cd /kaggle/working
from IPython.display import FileLink
FileLink(r'ckpts/checkpoint_50/checkpoint')

!python -m pip install PyDrive2

%%writefile settings.yaml
client_config_backend: settings
client_config:
 client_id: 49621581740-a3fm39vtadtnmhrfmumoijj6jk9i4ij0.apps.googleusercontent.com
 client_secret: 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
save_credentials: True
save_credentials_backend: file
save_credentials_file: credentials.json
get_refresh_token: True
oauth_scope:
 - https://www.googleapis.com/auth/drive.file
 - https://www.googleapis.com/auth/drive.install

%%writefile upload.py
# Original author: Evren Yurtesen - https://github.com/yurtesen/
"""
Uploads a file to a specific folder in Google Drive and converts it to a
Google Doc/Sheet/etc. if possible.
usage: upload.py 
example usage: upload.py 0B5XXXXY9KddXXXXXXXA2c3ZXXXX /path/to/my/file
"""
import sys
from os import path
from pydrive2.auth import GoogleAuth
from pydrive2.drive import GoogleDrive
from pydrive2.settings import LoadSettingsFile
gauth = GoogleAuth()
gauth.CommandLineAuth()
drive = GoogleDrive(gauth)
# If provided arguments incorrect, print usage instructions and exit.
if len(sys.argv) < 2:
 print("usage: upload.py ")
 exit(1) # Exit program as incorrect parameters provided.
parentId = sys.argv[1]
myFilePath = sys.argv[2]
myFileName = path.basename(sys.argv[2])
# Check if file name already exists in folder.
file_list = drive.ListFile(
 {
 "q": '"{}" in parents and title="{}" and trashed=false'.format(
 parentId, myFileName
 )
 }
).GetList()
# If file is found, update it, otherwise create new file.
if len(file_list) == 1:
 myFile = file_list[0]
else:
 myFile = drive.CreateFile(
 {"parents": [{"kind": "drive#fileLink", "id": parentId}]}
 )
# Upload new file content.
myFile.SetContentFile(myFilePath)
myFile["title"] = myFileName
# The `convert` flag indicates to Google Drive whether to convert the
# uploaded file into a Google Drive native format, i.e. Google Sheet for
# CSV or Google Document for DOCX.
print("uploading >>>")
myFile.Upload()

!python upload.py '1adeXlEvClGh85JYdP1aCPmdvDbbzP7YL' a.zip

sshpass -p '{password}' scp -rp ./Documents/{folder_name_old}/ {RemoteUsername}@{RemoteIP_addr}:/home/{RemoteUsername}/{folder_name_new}

sshpass -p '{password}' rsync -avz ./Documents/{folder_name_old}/ {RemoteUsername}@{RemoteIP_addr}:/home/{RemoteUsername}/{folder_name_new}

!npm install -g n 
!n 20.8.1

!cp -r /content/drive/MyDrive/3D/20220714_132152.obj /content

!npm install -g obj2gltf

input = '/content/20220714_132152.obj/20220714_132152.obj'
output = '/content/20220714_132152.obj/20220714_132152.glb'
!npx obj2gltf -i {input} -o {output} # >> !obj2gltf -i {input}.obj -o {output}.glb

!npm i gltfjsx@6.2.13

!npx gltfjsx {output} --transform

!pip install trimesh
import numpy as np
import trimesh
mesh = trimesh.load_mesh('/content/20220714_132152-transformed.glb')
mesh.show()

from IPython.display import HTML
import base64
# Load GLB as base64
with open("/content/combined_scene.glb", "rb") as f:
 glb_data = base64.b64encode(f.read()).decode("utf-8")
HTML(f"""
<iframe srcdoc="
<!DOCTYPE html>
<html lang='en'>
 <head>
 <script type='module' src='https://unpkg.com/@google/model-viewer/dist/model-viewer.min.js'></script>
 <style>html, body {{ margin: 0; height: 100%; }}</style>
 </head>
 <body>
 <model-viewer
 src='data:model/gltf-binary;base64,{glb_data}'
 alt='3D scene'
 auto-rotate
 camera-controls
 background-color='#FFFFFF'
 style='width:100%; height:100%;'>
 </model-viewer>
 </body>
</html>
" width="100%" height="600px" style="border:0;"></iframe>
""")

csv_dir = "/content/csvs"
prefix = ""
end = ["common_part_pf_filename"]
ex_b = prefix+end[0]
import os
csvs_list = [os.path.join(csv_dir, f) for f in os.listdir(csv_dir) if f.__contains__(ex_b)]
csvs_list.sort(reverse=True) 
print(csvs_list)
# importing pandas
import pandas as pd 
# merging two csv files
df = pd.concat(map(pd.read_csv, csvs_list), ignore_index=True)
d = ['name1', 'name2', 'name3'] 
#if there are 3 columns else add more as requirement
df.columns = d
print(df)
df.to_csv("final_filename.csv")

import geopandas as gpd
from shapely.geometry import Point
shapefile_path = "../data/shapefile/india_states/india_states.shp" # Replace with your shapefile path
gdf = gpd.read_file(shapefile_path)
polygon = gdf.geometry[0]
## Extract lat/lon from the dataset
latitudes = dataset['lat'].values
longitudes = dataset['lon'].values
points_inside = [(lat, lon) for lat in latitudes for lon in longitudes if polygon.contains(Point(lon, lat))]
points_inside