Topics:

 Coordinate Systems
 Transformations
 Python Code: Applications in IT and Robotics
------------------------------------------------------------------
Cartesian Coordinate System 2D
 Draw in a plane two mutually perpendicular number lines ′ and ′ ,
horizontal and vertical called x-axis and y-axis respectively.

 The point of intersection is called “Origin” and is denoted by “O”.

 The x-axis and y-axis have divided the plane into four parts, that are
called “Quadrants”. They are named Q1, Q2, Q3, and Q4.

Y y-axis

Q
x-axis
Origin

′ O X

Y'
Cartesian (Rectangular) Coordinate System 2D

In Cartesian Coordinates,

we mark a point by

how far along

and

how far up

it is

Polar Coordinate System 2D

In Polar Coordinates,
we mark a point by
how far away
and
what angle
it is
Visual explanation of Polar Coordinate

[Link]
Conversion Formulas

From Cartesian to Polar From Polar to Cartesian

 = +  = × &' (( )

 = tan !
( / )  = × )*+( )

Precaution …

when converting from Cartesian to Polar coordinates ...

the calculator can give the wrong value of tan-1

It all depends what Quadrant the point is in!

Use following to fix things:

• Quadrant I: Use the calculator value

• Quadrant II: Add 180°

• Quadrant III: Add 180°

• Quadrant IV: Add 360°

Cartesian Coordinate System in 3D

• Definition and basics:

• Axes ( , , 6).

• Representing points as 8( , , 6)

• Visualization in 3D:

• planes ( -plane, 6-plane, 6-plane).

Polar Coordinate System in 3D
As you probably have already guessed, 3D polar coordinates
have three values. But is the third coordinate another linear
distance (like r) or is it another angle (like θ)?

If we add a linear distance, we have cylindrical coordinates.

If we add another angle instead, we have spherical coordinates.

Cylindrical Coordinate System

The cylindrical coordinate system extends the polar coordinate

system into three dimensions by adding a height component <. It
is particularly useful for modeling objects with cylindrical or
rotational symmetry, such as pipes, cylinders, and spirals.

A point in the cylindrical system is described by 8( , , <).

 : The radial distance from the origin to the projection of
the point on the − 8?@AB
 : The angle between the positive − @ CD and the line
connecting the origin to the projection.
 <: The height of the point above or below the -plane, like
Cartesian system.
Conversion Formulas

From Cylindrical to From Cartesian to

Cartesian Cylindrical
 = EF)( )  = +
 = )*+( )  = GH+ !
I J
 <=<
 <=<

Spherical Coordinate System

The spherical coordinate system represents points in three-

dimensional space using three values:

radial distance, polar angle, and azimuthal angle.

A point in the spherical system is described by P(K, , L)

It is ideal for objects or problems involving spherical symmetry,

such as planets, stars, or electromagnetic fields.
K: The radial distance from the origin to the point (always non-
negative).

: The angle, measured in the -plane from the positive −

@ CD (similar to the angle in polar coordinates).

L: The polar angle, measured from the positive z-axis down to

the point.

Visual Representation

Cylindrical Coordinate System

[Link]

Spherical Coordinate System

[Link]
Conversion Formulas

From Spherical to From Cartesian to

Cartesian Spherical
 = K )*+(L) EF)( )  K = + +<

!
 = K )*+(L) )*+( )  = GH+ I J

! <
 < = K EF)(L)  L = EF) I KJ

Solution (a)
 Q Q
So for, (M, N, O) = I4, , J

( , , 6) = R√2, √6, 2√2V

Exercise
Python program
Python program that provides a menu for the user to choose a
coordinate transformation. It includes conversions between
Cartesian, Cylindrical, and Spherical coordinates in both
directions.
import math

def cartesian_to_cylindrical(x, y, z):

r = [Link](x**2 + y**2)

theta = math.atan2(y, x) # Angle in radians

return r, theta, z

def cylindrical_to_cartesian(r, theta, z):

x = r * [Link](theta)

y = r * [Link](theta)

return x, y, z

def cartesian_to_spherical(x, y, z):

r = [Link](x**2 + y**2 + z**2)

theta = math.atan2(y, x) # Azimuthal angle in radians

phi = [Link](z / r) if r != 0 else 0 # Polar angle in radians

return r, theta, phi

def spherical_to_cartesian(r, theta, phi):

x = r * [Link](phi) * [Link](theta)
 y = r * [Link](phi) * [Link](theta)

z = r * [Link](phi)

return x, y, z

def cylindrical_to_spherical(r, theta, z):

rho = [Link](r**2 + z**2)

phi = math.atan2(r, z) # Polar angle in radians

return rho, theta, phi

def spherical_to_cylindrical(rho, theta, phi):

r = rho * [Link](phi)

z = rho * [Link](phi)

return r, theta, z

# Menu for user input

while True:

print("\nCoordinate Transformation Options:")

print("1. Cartesian to Cylindrical")

print("2. Cylindrical to Cartesian")

print("3. Cartesian to Spherical")

print("4. Spherical to Cartesian")

print("5. Cylindrical to Spherical")

print("6. Spherical to Cylindrical")

print("0. Exit")

choice = input("Enter your choice (0-6): ")

if choice == '0':

print("Exiting the program.")

break

if choice in ['1', '2', '3', '4', '5', '6']:

if choice in ['1', '3']:

x = float(input("Enter x: "))

y = float(input("Enter y: "))

z = float(input("Enter z: "))

elif choice == '2':

r = float(input("Enter r: "))

theta = float(input("Enter theta (in radians): "))

z = float(input("Enter z: "))

elif choice == '4':

r = float(input("Enter r: "))

theta = float(input("Enter theta (in radians): "))

phi = float(input("Enter phi (in radians): "))

elif choice == '5':

r = float(input("Enter r: "))

theta = float(input("Enter theta (in radians): "))

z = float(input("Enter z: "))

elif choice == '6':

rho = float(input("Enter rho: "))

theta = float(input("Enter theta (in radians): "))

 phi = float(input("Enter phi (in radians): "))

# Perform the transformation based on choice

if choice == '1':

result = cartesian_to_cylindrical(x, y, z)

print(f"Cylindrical Coordinates (r, theta, z): {result}")

elif choice == '2':

result = cylindrical_to_cartesian(r, theta, z)

print(f"Cartesian Coordinates (x, y, z): {result}")

elif choice == '3':

result = cartesian_to_spherical(x, y, z)

print(f"Spherical Coordinates (r, theta, phi): {result}")

elif choice == '4':

result = spherical_to_cartesian(r, theta, phi)

print(f"Cartesian Coordinates (x, y, z): {result}")

elif choice == '5':

result = cylindrical_to_spherical(r, theta, z)

print(f"Spherical Coordinates (rho, theta, phi): {result}")

elif choice == '6':

result = spherical_to_cylindrical(rho, theta, phi)

print(f"Cylindrical Coordinates (r, theta, z): {result}")

else:

print("Invalid choice. Please enter a number between 0 and 6.")

Output

Applications: Python Implementation (Spherical System)

Visualizing a Sphere Using Spherical Coordinates

Code provides a foundational understanding of how spherical

coordinates are used to model 3D shapes in computer graphics.
It can be extended to more complex applications like texture
mapping or animations.
import numpy as np

import [Link] as plt

from mpl_toolkits.mplot3d import Axes3D

# Step 1: Define spherical coordinate parameters

phi = [Link](0, [Link], 100) # Polar angle from 0 to π

theta = [Link](0, 2 * [Link], 100) # angle from 0 to 2π

phi, theta = [Link](phi, theta) # Create a grid of angles

# Step 2: Define radius of the sphere

radius = 1

# Step 3: Convert spherical to Cartesian coordinates

x = radius * [Link](phi) * [Link](theta)

y = radius * [Link](phi) * [Link](theta)

z = radius * [Link](phi)

# Step 4: Create a 3D plot

fig = [Link](figsize=(8, 6))

ax = fig.add_subplot(111, projection='3d')

ax.plot_surface(x, y, z, cmap='viridis', edgecolor='k', alpha=0.7)

# Step 5: Customize the plot

ax.set_title("Sphere Visualized Using Spherical Coordinates", fontsize=14)

ax.set_xlabel("X-axis")

ax.set_ylabel("Y-axis")

ax.set_zlabel("Z-axis")
# Step 6: Show the plot

[Link]()

Output
Applications: Python Code Implementation
(Cylindrical System)
Robotic Arm Pick-and-Place Using Cylindrical Coordinates

Code illustrates how cylindrical coordinates are essential for

simplifying robotic motion in real-world applications.
import numpy as np

import [Link] as plt

from mpl_toolkits.mplot3d import Axes3D

# Step 1: Define parameters for the robotic arm

radius = 5 # Fixed radius of the circular motion

height_pick = 0 # Height at the picking point

height_place = 8 # Height at the placing point

theta_pick = [Link] / 2 # Angle where the object is picked (90 degrees)

theta_place = 3 * [Link] / 2 # Angle where the object is placed (270 degrees)

steps = 100 # Number of steps for smooth motion

# Step 2: Generate circular motion for the robotic arm

theta = [Link](theta_pick, theta_place, steps) # Circular motion from pick to place

r = radius * np.ones_like(theta) # Fixed radius

z = [Link](height_pick, height_place, steps) # Linear vertical motion

# Step 3: Convert cylindrical coordinates to Cartesian coordinates

x = r * [Link](theta)
y = r * [Link](theta)

# Step 4: Plot the robotic arm's motion

fig = [Link](figsize=(10, 6))

ax = fig.add_subplot(111, projection='3d')

# Plot the arm's base

[Link](0, 0, 0, color='black', s=100, label="Base")

# Initialize plot elements

arm_line, = [Link]([], [], [], color='blue', linewidth=2, label="Robotic Arm")

pick_point = [Link]([], [], [], color='green', s=50, label="Pick Point")

place_point = [Link]([], [], [], color='red', s=50, label="Place Point")

# Mark the pick and place points

[Link](radius * [Link](theta_pick), radius * [Link](theta_pick), height_pick, color='green',

s=50)

[Link](radius * [Link](theta_place), radius * [Link](theta_place), height_place, color='red',

s=50)

# Customize plot

ax.set_xlim(-radius - 1, radius + 1)

ax.set_ylim(-radius - 1, radius + 1)

ax.set_zlim(-1, height_place + 1)

ax.set_xlabel("X-axis")

ax.set_ylabel("Y-axis")

ax.set_zlabel("Z-axis")

ax.set_title("Robotic Arm Pick-and-Place Operation", fontsize=14)

[Link]()

# Step 5: Animate the motion

for i in range(steps):

# Plot the arm line as a connection between the base and the current point

arm_line.set_data([0, x[i]], [0, y[i]])

arm_line.set_3d_properties([0, z[i]])

[Link](0.01) # Pause to create animation effect

# Final plot display

[Link]()

Output