OpenGL Projects

How to Calculate Time Complexity

2026-10-02T03:04:27.510+05:30

What Is Time Complexity?

Time complexity describes how the running time of an algorithm changes when the input size grows.

It does not measure the exact time in seconds. Instead, it shows how efficiently an algorithm works.

For example, an algorithm may take:

1 step for 1 item.
10 steps for 10 items.
1,000 steps for 1,000 items.

This algorithm grows in a direct way. Its time complexity is called O(n). Here, 𝑛 represents the size of the input.

What is Big O Notation?

Big O notation is used to describe time complexity.

It focuses on the general growth of an algorithm and ignores small details, such as:

The computer’s speed.
Small constants.
Minor operations.
Exact execution time.

Some common time complexities are:

Complexity	Name	Example
O(1)	Constant Time	Accessing an array item
O(log ⁡n)	Logarithmic Time	Binary search
O(n)	Linear Time	Reading every item in a list
O(n log⁡ n)	Linearithmic Time	Efficient sorting
O(n²)	Quadratic Time	Comparing every pair of items
O(2ⁿ)	Exponential Time	Some recursive problems
O(n!)	Factorial Time	Trying every possible arrangement

The lower the growth rate, the better the algorithm usually performs for large inputs.

Why Is Time Complexity Important?

Time complexity helps you compare algorithms before writing or running them.

Suppose you need to search for a name in a list. You could check every name one by one, or you could use a faster search method if the list is sorted.

Understanding time complexity helps you:

Choose better algorithms.
Write faster programs.
Handle large amounts of data.
Find slow parts of your code.
Prepare for coding interviews.

How to Calculate Time Complexity

Use these simple steps to calculate the time complexity of an algorithm.

Step 1: Identify the Input Size

Find the value that represents the input size.

Usually, this value is called 𝑛.

For example:

def print_items(items):
	for item in items:
		print(item)

The input size is the number of items in the list. We call it 𝑛.

Step 2: Count the Main Operation

Find the operation that is repeated the most.

In the example above, print(item) runs once for every item.

If the list contains 𝑛 items, the operation runs 𝑛 times.

Therefore, the time complexity is:

Step 3: Check Loops

A single loop that runs 𝑛 times usually has a time complexity of 𝑂(𝑛).

Example:

for i in range(n):
  print(i)

The loops runs 𝑛 times, so: Time complexity: O(n)

Step 4: Check Nested Loops

Nested loops usually multiply their time complexities.

Example:

for i in range (n):
for j in range (n):
print (i, j)

Step 5: Check Separate Loops

Separate loops are usually added together.

For example:

for i in range(n):
									print(i) 
                                 for j in range(n):
                                 print(j)

The first loop takes 𝑂(𝑛).

The second loop also takes 𝑂(𝑛).

Together: 𝑂(𝑛)+𝑂(𝑛)=𝑂(2𝑛)

In Big O notation, constants are removed: 𝑂(2𝑛)=𝑂(𝑛)

Therefore, the final time complexity is: O(n)

Step 6: Remove Constants

Example:

(5𝑛)=𝑂(𝑛)

And

𝑂(3𝑛²+2𝑛+10)=𝑂(𝑛)

We keep only the fastest-growing term.

Common Time Complexity Examples

O(1): Constant Time

An operation takes the same amount of time regardless of the input size.

def get_first_item(items):
return items[0]

The function gets one item. It does not need to check every item.

Time complexity: O(1)

O(n): Linear Time

The running time grows directly with the input size.

def find_item(items, target):
for item in items:
if item == target:
return True
return False

In the worst case, the function checks every item.

Time complexity: O(n)

O(log n): Logarithmic Time

The input becomes smaller during each step.

A common example is binary search.

Time complexity: O(log n)

If a search space is divided in half again and again, the algorithm often has logarithmic time complexity.

O(n log n): Linearithmic Time

This complexity often appears in efficient sorting algorithms, such as merge sort.

An algorithm may process all 𝑛 n items while also dividing the problem into smaller parts.

Time complexity: O(n log n)

O(n²): Quadratic Time

The algorithm performs an operation for every pair of items.


def show_pairs(items):
for first in items:
for second in items:
print(first, second)

Both loops run n times 𝑛 × 𝑛 = 𝑛²

Time Complexity : 𝑛²

How to Calculate Complexity of Loops

A Loop That Increases by One


i=1

while i < n:
	print (i)
    i*=2

The value doubles after every step: 1, 2, 4, 8, 16, ...

The number of steps is about log ₂ n.

Time Complexity : O (log n)

Two Nested Loops With Different Sizes


   for i in range (n):
   	for j in range (m):
		print (i, j)

The Outer loop runs n times

the inner loop runs m times

Therefeore o(nxm)=O(nm)

Do not always replace both variables with . If the input sizes are different, keep both variables.

How to Calculate Recursive Time Complexity

Recursion can be more difficult to analyze.

Consider this function:

def countdown(n):
    if n==0:

        return 
  
   print(n)
countdown(n - 1)

The function calls itself once for each value of 𝑛.

Therefore:

<code>Time complexity: O(n)</code>

Now consider a function that makes two recursive calls:


    def example(n):
        if n <=1: 
            return 
    example(n - 1) 
    example(n - 1)

The number of calls grows very quickly. Its time complexity is approximately: <code>O(2ⁿ)</code>

When analyzing recursion, ask:

How many recursive calls are made?
How much does the input shrink each time?
Is there one recursive call or more than one?
Is the result stored and reused?

Best, Average, and Worst Cases

An algorithm can behave differently depending on the input.

Best Case

The algorithm finishes as quickly as possible. For example, a search function may find the target in the first position.

Average Case

The algorithm takes an average amount of time for typical input.

Worst Case

The algorithm takes the most time possible. For example, a search function may find the target at the last position or not find it at all. When people discuss Big O notation, they often mean the worst-case time complexity.

Time Complexity Rules to Remember

These rules make calculations easier:

A single statement is usually 𝑂 ( 1 ).
A loop that runs 𝑛 n times is usually 𝑂 ( 𝑛 ).
Nested loops are usually multiplied.
Separate sections are added.
Constants are removed.
Keep the fastest-growing term.
A loop that repeatedly divides the input often has 𝑂 ( log ⁡ 𝑛 ) complexity.
If an algorithm handles two input sizes, use 𝑂 ( 𝑛 𝑚 ) when appropriate.

Worked Example

Consider this code:


    def process(numbers):
         for number in numbers: 
            print(number) 
        for i in range(len(numbers)): 
        for j in range(len(numbers)): 
            print(i, j)

Let the number of items be 𝑛.

The first loop has: 𝑂 ( 𝑛 )

The nested loops have: 𝑂 ( 𝑛 2 )

Together: 𝑂 ( 𝑛 ) + 𝑂 ( 𝑛 2 )

The 𝑛² term grows faster than the 𝑛 n term, so we remove 𝑂 ( 𝑛 ) O(n).

Final answer: Time complexity: O(n²)

Time Complexity vs Space Complexity

Time complexity measures how much time an algorithm needs. Space complexity measures how much extra memory it needs.

For example:

def copy_items(items): 
    result=[] 

    for item in items:
     result.append(item) 
return result

The function processes every item, so its time complexity is: O(n) It also creates a new list containing 𝑛 items, so its extra space complexity is: text O(n)

These are different measurements, but both are important when evaluating an algorithm.

Frequently Asked Questions

Is O(1) always faster than O(n)?

Usually, yes for large inputs. However, actual speed can depend on the hardware, programming language, and operations being performed.

Are constants ignored in Big O?

Big O focuses on how an algorithm grows as the input becomes very large. Constants have less effect on growth than terms such as 𝑛 n, 𝑛 2 n 2 , or 2 𝑛 2 n .

What is the fastest time complexity?

𝑂 ( 1 ) O(1) is generally considered the most efficient common time complexity. However, an 𝑂 ( log ⁡ 𝑛 ) O(logn) algorithm can also be very fast for large inputs.

Is O(n²) always bad?

Not always. For small inputs, an 𝑂 ( 𝑛 2 ) O(n 2 ) algorithm may work well. It becomes a problem when the input size grows.

How do I analyze a loop that runs from 1 to n?

If it increases by one each time, it usually has 𝑂 ( 𝑛 ) O(n) time complexity.

To calculate time complexity, identify the input size, count repeated operations, analyze loops and recursion, combine the terms, and remove constants.

The most important patterns are:

One operation: 𝑂 ( 1 ) O(1).
One loop: 𝑂 ( 𝑛 ) O(n).
A loop that halves the input:𝑂 ( log ⁡ 𝑛 ).
Nested loops: 𝑂 ( 𝑛 2 ) O(n 2 ).
Efficient sorting: often 𝑂 ( 𝑛 log ⁡ 𝑛 ).

With practice, you can look at a piece of code and quickly estimate how its running time will grow.

Big O Examples in Python

2026-09-27T02:59:22.899+05:30

Here are some common Big O examples in Python, with short code snippets and explanations of time complexity of each of them. First we see the general examples then we go with some practice exercise with solutions.

Steps to Learn the Big O Examples in Python

First we are go through the Common Big O classes 𝑂(1), 𝑂(log 𝑛), 𝑂(𝑛), 𝑂(𝑛 log 𝑛), and 𝑂(𝑛2) in simple code pattern
Learn the Python Data Structures with quick overview
Go Through the Practical Example with code snippets.
See Some Interview Questions

1. Common Big O classes Examples in Python

1.1. Constant time — O(1)

Operations that take the same amount of time regardless of input size ie n.

def find_first_index(list1):
    print(list1[0])

Whether items contains 10 elements or 10 million elements, accessing items[0] is O(1).

1.2. Linear time — 𝑂(𝑛)

The work grows proportionally with the input size, execution time scales one to one with input size.

def print_items(items):
    for item in items:
        print(item)

If there are n items, the loop runs n times. Searching an unsorted Python list can take O(n) in the worst case.

1.3. Logarithmic - O(log n)

The algorithm repeatedly cuts the problem down, often by half with every iteration. It is highly efficient for large datasets.

A classic example is binary search:

def binary_search(arr, target):
    left, right = 0, len(arr) 

    while left <= right:
        mid = (left + right) 

        if arr[mid] == target:
            return True
        elif arr[mid] <target:
            left = mid + 1
        else:
            right = mid - 1

    return False

Each step eliminates about half of the remaining elements.

1.4. Linearithmic - O(n log n)

The Time of an alogorithm grows at a liner log arthmic rate with the size of input, n which means performace is impacted with the input size and lograthim of the input size. Common in efficient sorting algorithms.

items.sort()

Python's list.sort() / sorted() use Timsort, whose worst-case time complexity is O(n log n).

Example:

numbers = [5, 2, 8, 1, >3]
numbers.sort()

1.5. Quadratic - O(n²)

Usually occurs when you have a loop inside another loop.

def print_pairs(items):
    for x in items:
        for y in items:
            print(x, y)

For n items:

Outer loop → n
Inner loop → n
Total → n × n

A common example is a simple comparison of every pair.

1.6. Exponential - O(2ⁿ)

The amount of work doubles as n increases by one.

A classic example is the naive recursive Fibonacci implementation:

def fibonacci(n):
    if n <= 1:
        return n

    return fibonacci(n - 1) + fibonacci(n - 2)

This repeatedly calculates the same values. Using dynamic programming can reduce this dramatically.

The Time Complexities in python Summarized

O(1) — Constant time complexity: An algorithm exhibits constant time complexity when its execution duration remains unchanged irrespective of the input magnitude. Illustration: retrieving an element from an array.

O(log n) — Logarithmic time complexity: An algorithm demonstrates logarithmic time complexity when its execution duration increases logarithmically relative to the input magnitude. Illustration: binary search methodology.

O(n) — Linear time complexity: An algorithm exhibits linear time complexity when its execution duration increases proportionally with the input magnitude. Illustration: linear search methodology.

O(n log n) — Linearithmic time complexity: An algorithm demonstrates linearithmic time complexity when its execution duration increases at a linear-logarithmic proportion relative to the input magnitude. Illustration: merge sort algorithm.

O(n²) — Quadratic time complexity: An algorithm exhibits quadratic time complexity when its execution duration increases quadratically with the input magnitude. Illustration: bubble sort algorithm.

O(2n) — Exponential time complexity: An algorithm demonstrates exponential time complexity when its execution duration increases exponentially relative to the input magnitude. Illustration: naive recursive Fibonacci sequence implementation.

O(n!) — Factorial time complexity: An algorithm exhibits factorial time complexity when its execution duration increases at a factorial proportion with the input magnitude. Illustration: brute-force approach to the traveling salesman problem

Quick Summary Table Python examples

Big O	Python example	Idea
O(1)	`items[0]`	Constant
O(log n)	Binary search	Halves the problem
O(n)	`for x in items`	Visit each item
O(n log n)	`items.sort()`	Efficient sorting
O(n²)	Nested loops	Compare pairs
O(2ⁿ)	Naive Fibonacci	Repeated branching

2. Common Python data structures

Now we are going to see common Python data structures (list, dict, set, tuple)

Python Data Structures — Big O Cheat Sheet

Operation	List	Tuple	Set	Dict
Access by index	O(1)	O(1)	—	—
Search (x in)	O(n)	O(n)	O(1) avg.	O(1) avg.
Append	O(1) amortized	—	O(1) avg.	O(1) avg.
Insert at beginning	O(n)	—	—	—
Insert at end	O(1) amortized	—	—	O(1) avg.
Delete by value	O(n)	—	O(1) avg.	O(1) avg.
Access by key	—	—	—	O(1) avg.
Sorting	O(n log n)	sorted() → O(n log n)

2.1. Python List

A Python list is essentially a dynamic array.

Access — O(1)

numbers = [10, 20, 30, 40, 50]
print(numbers[3])

Python can directly calculate where index 3 is located.

O(1)

Append — O(1) amortized

numbers.append(60)

Usually, Python simply adds the element at the end.

O(1) amortized

"amortized"? Occasionally Python needs to allocate a larger block of memory and copy elements, which takes O(n), but over many appends the average cost is O(1).

Insert at beginning — O(n)

numbers.insert(0, 5)

Existing elements have to be shifted:

[10, 20, 30, 40]
 ↓
[5, 10, 20, 30, 40]

(n)

if you frequently add/remove items from the beginning, consider collections.deque instead of a list.

Searching a List — O(n)

numbers = [10, 20, 30, 40, 50]

if 40 in numbers:
    print("Found")

may need to check:

10 → 20 → 30 → 40

Worst case:

10 → 20 → 30 → 40 → 50 → not found

So searching a list is typically:

O(n)

Dictionary — O(1) Average

Dictionaries use hash tables.

person = {
    "name": "Alice",
    "age": 25
}

print(person["name"])

Finding "name" is typically:

O(1) average

This is why dictionaries are extremely useful for fast lookups.

Example

Instead of:

users = ["Alice", >"Bob", >"Charlie"]


if >"Charlie" >in users:
    ...

you could use:


users = >{
    >"Alice": >101,
    >"Bob": >102,
    >"Charlie": >103
}

if >"Charlie" >in users:
    ...

The list lookup is O(n), while dictionary lookup is O(1) average.

Set — O(1) Average Lookup

Sets are also hash-table based.

numbers = {10, 20, 30, 40, 50}

if >30 >in numbers:
    >print("Found")

Average:

O(1)

makes sets particularly useful when you need to repeatedly ask:
"Have I seen this value before?"

Example

seen = >set()

for number in numbers:
    >if number in seen:
        >print("Duplicate!")
    seen.add(number)

Each lookup is approximately O(1), so the entire loop is approximately:
O(n)

Tuple

Tuples are similar to lists for indexing.

numbers = (10, 20, 30, 40)

print(numbers[2])

access:
O(1)

Tuples are immutable, so you cannot do:

numbers.append(50)   ># Error

Searching is still:

30 >in numbers

What is the difference between list and tuple?

Ans

The List is changable, in which items can be added or remove but in the Tuple it can not be changed. If you want the items that you created can not be changed by anyone, than you can use tuple.
list1=[1,2,3]
list1[1]=1000
print(list1)
tup =(1,2,3)
# tup[1]=100 # it can not be changed.

Big O Patterns to Memorize

list[index]       → O(1)

list.append(x)    → O(1) amortized

list.pop()        → O(1)

list.insert(0,x)  → O(n)

list.pop(0)       → O(n)

x in list         → O(n)

x in set          → O(1) average

dict[key]         → O(1) average

for x in list     → O(n)

nested loops      → O(n²)

list.sort()       → O(n log n)

Practice exercises with solutions

Exercise 1

def ex1(lst):
    return lst[0] + lst[-1]

Question: What is the time complexity of ex1 in terms of n = len(lst)?

Solution:

def ex1(lst):
    return lst[0] + lst[-1]

Two list index operations: lst[0] and lst[-1].
Each index access is O(1).
Time complexity: O(1).

Exercise 2

def ex2(lst):
    total = 0
    for x in lst:
        total += x
    for x in lst:
        total -= x
    return total

Question: What is the time complexity of ex2?

Solution:

The function has two separate loops, each iterating through the list once.
First loop: runs n times → O(n).
Second loop: runs n times → O(n).
Total: O(n) + O(n) = O(n).
Time complexity: O(n).

Exercise 3

def ex3(lst):
    for i in range(len(lst)):
        for j in range(i, len(lst)):
            print(lst[i], lst[j])

Question: What is the time complexity of ex3?

Solution:

The function has nested loops, where the inner loop runs from the current index of the outer loop to the end of the list. In the worst case, this results in approximately n² iterations.
Outer loop: i from 0 to n−1.
Inner loop: j from i to n−1 → about (n − i) iterations.
Total iterations ≈ n + (n−1) + … + 1 = n(n+1)/2 = O(n²)
Time complexity: O(n²).

Exercise 4

def ex4(n):
    count = 0
    while n > 1:
        n = n // 2
        count += 1
    return count

Question: What is the time complexity of ex4 in terms of the input value n?

Solution:

The function divides n by 2 in each iteration until n becomes 1. This results in approximately log₂(n) iterations.
Each iteration halves n.
Number of halvings until n becomes 1 is about log₂(n).
Time complexity: O(log n).

Exercise 5

def ex5(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    return -1

Question: What is the worst-case time complexity of ex5?

Solution:

In the worst case, the target is not found in the list, and the function must iterate through all elements. Worst-case time complexity: O(n).

Exercise 6


def ex6(lst):
    d = {}
    for x in lst:
        d[x] = d.get(x, 0) + 1
    return d

Question: What is the time complexity of ex6? (Assume average-case dictionary operations.)

Solution:

The function iterates through the list once, and each dictionary operation (get and set) is O(1) on average.
Loop runs n times.
Each dict lookup/insert (d.get, d[...]) is O(1) on average.
Average-case time complexity: O(n).

Exercise 7


def ex7(lst):
    result = []
    for x in lst:
        result.append(x * 2)
    return result

Question: What are the time and space complexities of ex7?

Solution:

Solution: The function iterates through the list once, performing a constant-time operation for each element. Time complexity: O(n). The function creates a new list of the same size as the input list. Space complexity: O(n).

Loop runs n times; each append is O(1) amortized.
Creates a new list of size n. Time complexity: O(n).
Space complexity: O(n) extra space for result.

Exercise 8


def ex8(lst):
    total = 0
    for x in lst:
        for y in lst:
            total += x * y
    return total

Question: What is the time complexity of ex8?

Solution:

The function has nested loops, where the inner loop runs for each element of the list. In the worst case, this results in approximately n² iterations.

Outer loop: n iterations.
Inner loop: n iterations for each outer iteration.
Total operations ≈ n × n = n².
Time complexity: O(n²).

Exercise 9


def example(arr):
    arr.sort()

    for x in arr:
        print(x)

Question: What is the time complexity of mystery?

Solution:

Python's list.sort() uses Timsort, whose worst-case time complexity is: O(n log n), therafter loop is O(n) Therefore: O(n log n + n) The dominant term is n log n.
Time complexity:O(n log n)

Exercise 10


def example(arr):
    arr.sort()

    for x in arr:
        print(x)

Question: What is the time complexity of mystery?

Solution:

Each call creates two more calls: T(n) = 2T(n-1) + O(1)This produces exponential growth O(2ⁿ)
Time complexity:O(2ⁿ)

Exercise 11


def mystery(arr):
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
                return True

    return False

Question: What is the worst-case complexity?

Solution:

Worst case means no duplicate is found, so both loops run almost completely. n × n
Worst-case complexity Time complexity:O(n²)

20 Big-O Practice Questions in Python

Try to identify the time complexity of each snippet before checking the answer key.Assume n = len(arr) where applicable.

1. Easy

def example(n): for i in range(n): print(i)

Answer: O(?)

2. Constant work

 def
example(arr): print(arr[0]) print(arr[-1])

Answer: O(?)

3. Two loops

 def example(n): for i in range(n):
print(i) for j in range(n): print(j)

Answer: O(?)

4. Nested loops

 def example(n): for i in range(n): for j
in range(n): print(i, j)

Answer: O(?)

5. Different loop sizes

 def example(n): for i in range(n): for j in
range(10): print(i, j)

Answer: O(?)

6. Logarithmic

 def example(n): i = 1 while i < n: print(i) i *=2 Your

Answer: O(?)

7. Dividing

 def example(n): while n > 1: n //= 2

Answer: O(?)

8. Nested with logarithm

def
        example(n): for i in range(n): j = 1 while j < n: print(i, j) j *=2

Answer: O(?)

9. Triangular loop

 def example(n): for i in range(n): for j in range(i): print(i, j)

Answer: O(?)

10. Three nested loops

 def example(n): for i in range(n): for j in range(n): for k in range(n): print(i, j, k)

Answer: O(?)

11. List search

 def contains(arr, target): for x in arr: if x == target: return True return False What is
    the worst-case complexity?

Answer: O(?)

12. Dictionary lookup

 def find_user(users, name): return
    users[name] Assume users is a Python dictionary.

Answer: O(?)

13. Sorting + loop

 def example(arr):
    arr.sort() for x in arr: print(x)

Answer: O(?)

14. Nested list membership

 def example(arr, values):
    for x in arr: if x in values: print(x) Assume values is a list.

Answer: O(?)

15. Nested dictionary membership

 def example(arr, values): for x in arr: if x in values: print(x) This time, assume values is a
    set.

Answer: O(?)

16. Recursive — one branch

 def example(n): if n <= 1: return example(n - 1) Your

Answer: O(?)

17. Recursive — two branches

 def example(n): if n <= 1: return example(n - 1) example(n -
            1)

Answer: O(?)

18. Sneaky one

 def example(n): i = 1 while i < n: for j in range(n): print(i,
                j) i *=2

Answer: O(?)

19. Very sneaky

 def example(n): i = 1 while i < n: j=1 while j < n:
                    print(i, j) j *=2 i *=2

Answer: O(?)

20. Interview challenge

 def example(arr): n =
                    len(arr) for i in range(n): j = i while j < n: print(arr[i], arr[j]) j +=1

Answer: O(?)

#	Python code / question	Answer	Why?
1	for i in range(n):	O(n)	Loop runs n times
2	print(arr[0])<br>print(arr[-1])	O(1)	Fixed number of operations
3	Two separate for loops of n	O(n)	n + n = 2n → O(n)
4	for i in range(n)<br>inside for j in range(n)	O(n²)	n × n
5	for i in range(n)<br>inside for j in range(10)	O(n)	n × 10 = 10n → O(n)
6	i = 1 → i *= 2	O(log n)	Value doubles each time
7	n //= 2 repeatedly	O(log n)	Problem size halves each time
8	n loop + inner loop doubling j	O(n log n)	n × log n
9	Inner loop runs i times	O(n²)	0 + 1 + ... + n ≈ n²/2
10	Three nested n loops	O(n³)	n × n × n
11	Search through a list	O(n)	May examine every element
12	users[name] using dictionary	O(1) average	Hash-table lookup
13	arr.sort() + loop	O(n log n)	Sorting dominates O(n) loop
14	Loop + x in values where values is a list	O(n²)	n searches × O(n) search
15	Loop + x in values where values is a set	O(n) average	n × O(1) set lookup
16	example(n - 1) once	O(n)	One recursive call per level
17	Two example(n - 1) calls	O(2ⁿ)	Two branches at every level
18	n work inside log n loop	O(n log n)	n × log n
19	log n loop inside log n loop	O(log² n)	log n × log n
20	Inner loop starts at i	O(n²)	Approximately n²/2 operations

Python Big-O Interview Questions

Find 20 interview-style straightforward questions in tabular format below.

#	Interview Question	What to Identify
1	What is the time complexity of accessing arr[i] in a Python list?	Time complexity
2	What is the time complexity of x in my_list?	Average/worst case
3	What is the time complexity of x in my_set?	Average case
4	What is the complexity of dict[key]?	Average case
5	What is the complexity of arr.append(x)?	Amortized complexity
6	What is the complexity of arr.insert(0, x)?	Time complexity
7	What is the complexity of arr.pop()?	Time complexity
8	What is the complexity of arr.pop(0)?	Time complexity
9	What is the complexity of arr.sort()?	Time complexity
10	What is the complexity of this code?	Nested loops
11	What is the complexity of this code?	Logarithmic loop
12	What is the complexity of this code?	n × log n
13	What is the complexity of this code?	Triangular loop
14	What is the complexity of this recursive function?	Recursion
15	What is the complexity of this recursive function?	Recursion tree
16	Can O(n²) ever be faster than O(n)?	Big-O interpretation
17	What is the difference between O(n) and O(2n)?	Simplification
18	What is the difference between average and worst-case complexity?	Complexity concepts
19	What is space complexity?	Memory usage
20	Given two solutions, which has better asymptotic complexity?	Comparison

Big O Examples in C++

2026-09-25T00:04:41.040+05:30

Big O notation describes how an algorithm’s running time or space usage grows as the input size 𝑛 n increases.

In C++, you can see common Big O classes like 𝑂(1), 𝑂(log 𝑛), 𝑂(𝑛), 𝑂(𝑛 log 𝑛), and 𝑂(𝑛²) in simple code patterns and STL operations.

Common Big O classes with C++ examples

𝑂(1) – Constant time

The runtime does not depend on input size.


// Accessing an array element by index
int arr[1000];
int x = arr[5];  // O(1)

// Simple arithmetic / assignment
int y = a + b;           // O(1)
bool equal = (a == b);   // O(1)

// Push/back on vector (amortized)
std::vector<int> v;
v.push_back(10);  // amortized O(1)

Typical 𝑂(1) patterns: single statements, no loops depending on 𝑛, direct index access, basic arithmetic.

𝑂(𝑛) – Linear time

Runtime grows proportionally with 𝑛 usually a single loop over all elements.

// Sum of first n integers (loop version)
int sumOfNumbers(int n) {
    int sum = 0;
    for (int i = 1; i <= n; ++i) {  // runs n times
        sum += i;                    // O(1) work each time
    }
    return sum;                      // overall O(n)
}

// Linear search in an array
int linearSearch(const int arr[], int n, int target) {
    for (int i = 0; i < n; ++i) {   // up to n iterations
        if (arr[i] == target)
            return i;
    }
    return -1;                       // O(n)
}

// Traversing a vector
std::vector<int> v = {1,2,3,4,5};
for (int x : v) {                   // n elements
    std::cout << x << " ";          // O(1) per element
}                               // total O(n)

Patterns: one loop from 0 to 𝑛−1, iterating over a container once.

𝑂(log 𝑛) – Logarithmic time

Runtime grows with the number of times you can halve the problem; classic example is binary search.

// Binary search on a sorted array (iterative)
int binarySearch(const int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {                 // each step halves the range
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;                              // O(log n)
}

Also common in C++ STL: std::lower_bound, std::upper_bound, std::binary_search on sorted ranges are 𝑂(log 𝑛).

𝑂 ( 𝑛 log ⁡ 𝑛 ) – Linearithmic time

Typical for efficient sorting and some divide-and-conquer algorithms.

#include 
#include 

std::vector v = {5, 2, 9, 1, 5, 6};
std::sort(v.begin(), v.end());  // introsort: average O(n log n)

Most comparison-based sorts in C++ (std::sort, std::stable_sort) are 𝑂 ( 𝑛 log 𝑛 ) on average. 𝑂 ( 𝑛 2 ) – Quadratic time Usually nested loops where both depend on 𝑛 n; common in naive sorting algorithms.


// Bubble sort (worst/average case)
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {          // ~n times
        for (int j = 0; j < n - i - 1; ++j) {  // ~n times
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]); // O(1)
            }
        }
    }                                          // total O(n²)
}

// Simple double loop example
for (int i = 0; i < n; ++i) {        // n
    for (int j = 0; j < n; ++j) {    // n
        std::cout << i << " " << j;  // O(1)
    }                                // n * n = O(n²)
}

Also: worst-case of insertion sort and selection sort are 𝑂(𝑛²).

𝑂(2^𝑛)– Exponential time

Common in naive recursive solutions like Fibonacci without memoization.


// Naive recursive Fibonacci
int fib(int n) {
    if (n <= 1) return n;          // base case O(1)
    return fib(n - 1) + fib(n - 2); // each call branches into 2
}                                  // roughly O(2ⁿ)

Each increment of 𝑛 roughly doubles the number of calls.

Big O of common C++ STL operations

These are useful “real-world” examples when analyzing C++ code:

std::vector:

operator[], at(): 𝑂 ( 1 )
push_back: amortized 𝑂 ( 1 )
insert/erase in the middle: 𝑂 ( 𝑛 )

std::vector: std::array:

Index access: 𝑂 ( 1 )

std::list (doubly linked list):

Insert/erase at known iterator: 𝑂 ( 1 )
Traversal to find an element: 𝑂 ( 𝑛 )

std::unordered_set,std::unordered_map:

Average insert/lookup/erase: 𝑂 ( 1 )
Worst case (bad hash): 𝑂 ( 𝑛 )

std::set, std::map (balanced BST):

Insert/lookup/erase: 𝑂 ( log ⁡ 𝑛 )

std::sort, std::stable_sort:

Average: 𝑂 ( 𝑛 log ⁡ 𝑛 )
Worst case for <std::sort: >typically 𝑂 ( 𝑛 log ⁡ 𝑛 ) with introsort

Practical Big O Examples in C++

Presenting Few Simple Examples in C++ for Big O Notation

Complexity	Example	Evaluation
O(1)	Addition of a + b	A fixed number of operations regardless of input size
O(n)	Loop from 0 to n-1	Loop executes n times
O(log n)	Binary search	Search space is roughly halved each iteration
O(n²)	Two nested loops	n × n = n² iterations
O(n³)	Three nested loops	n × n × n = n³ iterations
O(2ⁿ)	Naive recursive Fibonacci	More precisely, its running time is O(φⁿ), often simplified to O(2ⁿ)
O(n!)	Recursive factorial	The recursive factorial is O(n), not O(n!)

Evaluation

1. O(1) — Constant

cin >> a >> b;  
cout << a + b;

There is a fixed amount of work, so:

Time = O(1)

Even if the values of a and b are very large, the number of program steps doesn't depend on n.

2. O(n) — Linear

 for (int i = 0; i < n; ++i) {
    cout << i << " ";
}

The loop executes n times.

Time = O(n)

3. O(log n) — Logarithmic

The binary search is a good example:

while (left <= right) {  
    int mid = left + (right - left) / 2;
    ...
}

Every iteration eliminates approximately half of the remaining elements.

For example:

1000 → 500 → 250 → 125 → ... → 1

So:

Time = O(log n)

One minor issue: your array contains only 7 elements, so technically that particular program has a fixed-size input and could be viewed as O(1). To demonstrate O(log n) properly, use an array whose size depends on n.

4. O(n²) — Quadratic

for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
        ...
    }
}

The inner loop runs n times for every one of the n outer iterations:

n × n = n²

Therefore:

Time = O(n²)

5. O(n³) — Cubic

You have three nested loops:

for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) for (int k = 1; k <= n; ++k)

That's:

n × n × n = n³

Therefore:

Time = O(n³)

6. O(2ⁿ) — Exponential

The Fibonacci example - A simple recursive algorithm that makes two recursive calls at each level:

#include <iostream>
using namespace std;
 
int fibonacci(int n) {     if (n <= 1) {         return n; 
    } 
    return fibonacci(n - 1) + fibonacci(n - 2); 
} 
int main(){     int n; 
    cin >> n; 

    cout << "Fibonacci of " << n << " is: " 
        << fibonacci(n) << endl; 

    cout << "This is O(2^n) - Exponential Complexity";
 
return 0;
}

O(2ⁿ) Commonly used simplified bound for this basic Big O Examples in C++

7. O(n!) — Factorial

To actually demonstrate O(n!), generate all permutations of n elements:

#include <iostream>
#include <vector>#include <algorithm>
using namespace std; 
void generatePermutations(vector<int>& arr, int index) { 
    if (index == arr.size()) { 
        for (int x : arr) { 
            cout << x << " "; 
        } 
        cout << endl; 
        return; } 
        for (int i = index; i < arr.size(); ++i){ 
            swap(arr[index], arr[i]); 
            generatePermutations(arr, index + 1); 
            swap(arr[index], arr[i]);
 } 

} 

int main() { 
    int n; 
    cin >> n; 

    vector arr(n); 

       for (int i = 0; i < n; ++i) { 
        arr[i] = i + 1;
 } 
generatePermutations(arr, 0); 

cout << "This is O(n!) - Factorial Complexity"; 

return 0; 

}

For n elements, there are:

n! = n × (n-1) × (n-2) × ... × 1

permutations.

So the algorithm has O(n!) time complexity (ignoring the additional O(n) work needed to print each permutation).

Calculate Big O time and space complexity with your own code.

Big O Cheat Sheet - Decoding Time and Space Complexity

2026-09-20T02:02:21.289+05:30

An algorithm is a step-by-step set of instructions designed to solve a specific problem or complete a task. There are multiple ways or multiples set of instructions to solve any problem or task. We may use different method to get the same solution, say different paths to reach same destination.

Imagine you're a programmer faced with solving a problem. There are often many ways to approach it, each with its own method or algorithm. But how do you know which solution is best? This is where evaluating algorithms comes into play.

Performance and efficiency are key factors when choosing an algorithm. Performance refers to how quickly your algorithm runs—its execution time. Efficiency, on the other hand, involves how much memory or resources your algorithm consumes. Both aspects are crucial because they affect how well your application runs in the real world.

For programmers, understanding these factors isn’t just about making software work; it’s about making it work well. This is where Big O, which we also call as Big O notation come to picture.

Understanding algorithm efficiency is essential for writing software that remains fast, reliable, and scalable. Big O notation provides a standard way to describe how an algorithm’s performance changes as the size of its input increases.

We have explained Big O Notations with Practice Problems in our previous post, here were are going to go for Big O cheat sheet which explains the most common time and space complexities, shows practical examples, and provides guidance for choosing efficient algorithms and data structures.

What Is Big O Notation? Big O notation describes the upper bound of an algorithm’s growth rate. In simple terms, it answers this question:
How does the amount of work or memory required by an algorithm change as the input size increases?
The input size is commonly represented by 𝑛 n. Big O focuses on the dominant factor and ignores constants and lower-order terms.

For example:

𝑂 ( 2 𝑛 + 10 ) = 𝑂 ( 𝑛 ) O(2n+10)=O(n)

As 𝑛 n becomes large, the 2 𝑛 2n term matters more than the constant 10 10, so the algorithm is classified as linear.

Big O can describe:

Time complexity: How long an algorithm takes to run.
Space complexity: How much additional memory an algorithm requires.
Scalability: How performance changes with larger inputs.

Complexity	Name	Example
O(1)	Constant	Accessing an array element by index
O(log ⁡n)	Logarithmic	Binary search
O(n)	Linear	Scanning an array
O(n log⁡ n)	Linearithmic	Efficient comparison-based sorting
O(n²)	Quadratic	Comparing every pair of elements
O(n³)	Cubic	Some matrix algorithms
O(2ⁿ)	Exponential	Brute-force subset generation
O(n!)	Factorial	Brute-force permutation generation

Big O for Common Data Structures

The following table shows typical time complexities for frequently used data structures. Values can vary depending on the implementation and operation.

Data structure	Access	Search	Insertion	Deletion
Array	O(1)	O(n)	O(n)	O(n)
Dynamic array	O(1)	O(n)	O(1) amortized at end	O(n)
Linked list	O(n)	O(n)	O(1) with a known node	O(1) with a known node
Hash table	Not typically indexed	O(1) average	O(1) average	O(1) average
Binary search tree	O(log ⁡n) average	O(log ⁡n) average	O(log⁡ n) average	O(log⁡n)O average
Balanced search tree	O(log⁡ n)	O(log⁡ n)	O(log ⁡n)	O(log ⁡n)
Heap	Not generally supported	O(n)	O(log ⁡n)	O(log⁡ n)

Big O Quick Reference

Complexity	Practical interpretation
O(1)	Excellent; unaffected by input size
O(log⁡ n)	Very efficient; scales well
O(n)	Efficient for most ordinary workloads
O(n log⁡ n)	Efficient for large-scale sorting and processing
O(n ²)	Often acceptable for small inputs
O(n³)	Usually limited to small datasets
O(2ⁿ)	Becomes impractical quickly
O(n!)	Practical only for very small inputs

The Big O Hierarchy (Best to Worst)

Complexity	Name	Practical Metaphor	Common Culprit / Example
O(1)	Constant	Grabbing a specific TV remote	Hash map lookup, array index access
O(log n)	Logarithmic	Binary search in a phone book	Halving search space (balanced BSTs)
O(n)	Linear	Scanning a single-file line of people	Single loop over an unsorted array
O(n log n)	Linearithmic	Sorting a deck via merge-sort/quicksort	Efficient comparison-based sorts
O(n ²)	Quadratic	Comparing every photo with every other photo	Nested loops over the same dataset
O(2ⁿ)	Exponential	Branching puzzle decisions (include/exclude)	Naive recursive Fibonacci, subset generation
O(n!)	Factorial	Generating all travel route permutations	Traveling Salesperson brute force

Amortized Time Complexity: Definition and Examples

2026-09-18T23:37:07.070+05:30

Amortized time complexity measures the average cost per operation over a sequence of operations on a data structure, even when some individual operations are expensive. Unlike worst-case analysis (which looks at a single operation in isolation) or average-case analysis (which relies on probability), amortized analysis guarantees that any sequence of n operations will take at most a certain total time, regardless of the order or pattern of operations.

Key Idea

Some operations are cheap most of the time but occasionally trigger an expensive "cleanup" or "resize" step. Amortized analysis spreads the cost of these rare expensive operations across the many cheap ones that precede them, showing that the average cost per operation remains low. Formally, if a sequence of m operations costs at most T(m) total time, the amortized cost per operation isT(m) / m.

Three Methods of Amortized Analysis

There are three standard techniques for performing amortized analysis:

Aggregate Method: Compute the total cost of m operations, then divide by m.
Accounting (Banker's) Method: Assign a "charge" to each operation; cheap operations overpay and store credit to subsidize expensive ones.
Potential Method: Define a potential function Φ that represents stored "energy"; amortized cost = actual cost + change in potential.

Classic Example 1: Dynamic Array (ArrayList, Python list, C++ vector)

The Problem

A dynamic array starts with a small fixed capacity and grows as elements are appended. When the array is full, it must allocate a larger array and copy all existing elements—a costly O(n) operation.

Naive Approach: Increase by 1

If the array grows by just 1 slot each time it fills up:

• The i-th insertion costs O(i) to copy i−1 elements.

• Total cost for n insertions: 1 + 2 + 3 + ... + n = O(n²).

• Amortized cost: O(n²) / n = O(n) per insertion.

This is inefficient.

Smart Approach: Doubling Strategy

Instead, double the capacity whenever the array is full:

• Most insertions cost O(1) (just place the element).

• Occasionally, when capacity is reached (at sizes 1, 2, 4, 8, ...), copy all elements to a new array of double size—costing O(n) for that insertion.

Aggregate Analysis

For n insertions:

• Cost of n simple insertions: n × O(1) = O(n).

• Cost of all resizing operations: 1 + 2 + 4 + 8 + ... + 2ᵏ ≤ 2n (geometric series, where 2ᵏ ≤ n).

• Total cost: O(n) + O(2n) = O(3n) = O(n).

• Amortized cost per insertion: O(n) / n = O(1).

Even though some insertions are O(n), the average is constant.

Accounting Method Explanation

Charge each insertion $3:

• $1 pays for the actual insertion.

• $2 is stored as credit on the newly inserted element.

When resizing from size n to 2n:

• The n/2 most recently added elements each have $2 credit, totaling $n.

• This credit pays for copying all n elements to the new array.

• The current insertion still costs $1, so total charge remains $3.

Thus, every insertion has an amortized cost of O(1).

Potential Method

Define potential Φ = 2 × (number of elements) − (capacity).

• For a normal insertion: actual cost = 1, potential increases by 2 → amortized cost = 1 + 2 = 3.

• For a resize: actual cost = n, potential drops by n → amortized cost = n − n = 0.

Again, amortized cost per operation is O(1).

Classic Example 2: Hash Table with Resizing

Hash tables provide O(1) average-case lookup, insertion, and deletion. However, when the load factor (elements / buckets) exceeds a threshold, the table must resize and rehash all elements—an O(n) operation.

Amortized Analysis

Using the doubling strategy (like dynamic arrays):

• Most insertions cost O(1) (hash and place in bucket).

• Occasional resizing costs O(n) to rehash all elements.

For n insertions:

• Total hashing operations: n (initial) + 1 + 2 + 4 + ... + 2ᵏ ≤ 3n.

• Amortized cost per insertion: O(3n) / n =O(1).

This is why hash tables are said to have O(1) amortized time complexity for insertions, even though worst-case individual operations are O(n).

Classic Example 3: Queue Using Two Stacks

A queue (FIFO) can be implemented with two stacks (LIFO):

Enqueue: Push onto stack_in (O(1)).
Dequeue: If stack_out is empty, pop all elements from stack_in and push them onto stack_out (O(n)), then pop from stack_out (O(1)).

Amortized Analysis

Each element is pushed onto stack_in once, moved to stack_out once, and popped once.
Total cost for n enqueue + n dequeue operations: O(3n) = O(n).
Amortized cost per operation: O(n) / (2n) = O(1).

Even though a single dequeue can be O(n), the average over many operations is constant.

Comparison Table

Data Structure	Operation	Worst-Case	Amortized	Why?
Dynamic Array	Append	O(n)	O(1)	Doubling spreads resize cost
Hash Table	Insert	O(n)	O(1)	Rehashing is rare with geometric growth
Two-Stack Queue	Dequeue	O(n)	O(1)	Each element moved at most twice
Disjoint Set (Union-Find)	Find/Union	O(log n)	O(α(n)) ≈ O(1)	Path compression + union by rank

Important Distinctions

Concept Definition Applies To Worst-case Maximum time for a single operation Any single operation Average-case Expected time over random inputs Probabilistic analysis Amortized Average time over any sequence of operations Sequence of operations on a data structure Crucial: Amortized analysis does not assume random inputs—it guarantees performance for the worst possible sequence of operations.

When Amortized Analysis Fails

Amortized O(1) relies on geometric growth (doubling). If a dynamic array grows by a fixed increment (e.g., +100 slots):

Resizing occurs O(n) times for n insertions.
Each resize copies O(n) elements on average.
Total cost: O(n²) → Amortized cost: O(n), not O(1).

Takeaway

Amortized time complexity reveals that some data structures are far more efficient in practice than their worst-case per-operation analysis suggests. By analyzing sequences of operations rather than isolated steps, we can prove strong guarantees—like O(1) amortized time for dynamic arrays and hash tables—that make these structures indispensable in real-world software.

Time Complexity Practice Problems : A Comprehensive Guide

2026-09-18T01:26:57.817+05:30

Time complexity analysis is a foundational skill for any programmer or computer science student, enabling you to predict how an algorithm's runtime scales with input size. Mastering this skill requires deliberate practice across a spectrum of problems—from simple loops to intricate recursive patterns.

Why Practice Time Complexity?

Understanding Big O notation theoretically is one thing; applying it fluently to unfamiliar code is another. Practice helps you:

Recognize common patterns instantly (e.g., nested loops = O(n²), halving = O(log n))
Avoid common pitfalls like miscounting triangular iterations or forgetting to drop constants
Build intuition for recursive algorithms and amortized analysis
Prepare confidently for technical interviews and exams

Core Concepts Recap

Before diving into problems, ensure you're comfortable with these rules:

Drop constants: O(3n) = O(n), O(n²/2) = O(n²)
Keep the dominant term: O(n² + n) = O(n²)
Sequential blocks add: O(n) + O(n) = O(n)
Nested blocks multiply: O(n) × O(n) = O(n²)
Halving/doubling loops: O(log n)
Graph algorithms: Typically O(V + E), where V = vertices, E = edges

Practice Problems by Difficulty

Beginner Problems (Single Loops & Constants)

Problem 1: Constant-Time Loop
What is the time complexity?

for i in range(1, 101):
    print(i)

Answer: O(1) — the loop runs a fixed 100 times, independent of input size.

Problem 2: Linear Scan

for i in range(n):
    print(array[i])

Answer: O(n) — one iteration per element.

Problem 3: Two Sequential Loops

for x in array:
    print(x)
for x in array:
    print(x * 2)

Answer: O(n) — sequential loops add: O(n) + O(n) = O(2n) = O(n).

Problem 4: Loop with Step

for i in range(1, n, 2):
    print(i)

Answer: O(n) — still linear; the step size (2) is a constant factor that gets dropped.

Intermediate Problems (Nested Loops & Logarithms)

Problem 5: Full Nested Loops

for i in range(n):
    for j in range(n):
        print(i, j)

Answer: O(n²) — n × n iterations.

Problem 6: Triangular Nested Loops

for i in range(n):
    for j in range(i + 1, n):
        print(i, j)

Answer: O(n²) — total iterations = n(n-1)/2, but constants are dropped.

Problem 7: Logarithmic Loop

i = n
while i > 0:
    i = i // 2
    print(i)

Answer: O(log n) — the variable halves each iteration.

Problem 8: Linear × Logarithmic

for i in range(n):
    j = 1
    while j < n:
        j *= 2

Answer: O(n log n) — outer loop runs n times, inner loop log n times.

Problem 9: Different Input Sizes

for x in array_a:      # length m
    for y in array_b:  # length n
        print(x, y)

Answer: O(m × n) — use separate variables for distinct input sizes.

Advanced Problems (Recursion & Complex Patterns)

Problem 10: Naive Fibonacci

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

Answer: O(2ⁿ) — each call branches into two more calls; recursion tree depth ≈ n.

Problem 11: Memoized Fibonacci

def fib_memo(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo)
    return memo[n]

Answer: O(n) — each unique subproblem (0 to n) is solved once.

Problem 12: Merge Sort

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)  # O(n)

Answer: O(n log n) — recurrence T(n) = 2T(n/2) + O(n).

Problem 13: Tower of Hanoi

def hanoi(n, source, target, aux):
    if n == 1:
        move(source, target)
        return
    hanoi(n-1, source, aux, target)
    move(source, target)
    hanoi(n-1, aux, target, source)

Answer: O(2ⁿ) — recurrence T(n) = 2T(n-1) + 1.

Problem 14: All Subsets (Power Set)

def subsets(arr, i=0, current=[]):
    if i == len(arr):
        print(current)
        return
    subsets(arr, i+1, current + [arr[i]])  # include
    subsets(arr, i+1, current)             # exclude

Answer: O(n × 2ⁿ) — 2ⁿ subsets, each taking O(n) to copy/print.

Problem 15: BFS on a Graph

from collections import deque
def bfs(graph, start):
    visited = {start}
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

Answer: O(V + E) — each vertex and edge is processed at most once.

Quick Reference Table

Pattern	Complexity	Example
Single loop over n	O(n)	Linear search
nested loops over n	O(n²)	Bubble sort
Triple nested loops	O(n³)	Naive matrix multiply
Loop halving/doubling	O(log n)	Binary search
Loop + inner halving	O(n log n)	Merge sort, heap sort
Recursive, halves input	O(log n)	Binary search (recursive)
Recursive, two calls on n/2 + O(n)	O(n log n)	Merge sort
Recursive, two calls on n-1	O(2ⁿ)	Naive Fibonacci, Hanoi
Memoized recursion	O(unique states)	DP Fibonacci
All subsets	O(n × 2ⁿ)	Power set
All permutations	O(n × n!)	Permutation generation
Graph BFS/DFS	O(V + E)	Traversal

How to Practice Effectively

Start simple: Master single and nested loops before tackling recursion.
Trace small inputs: Manually count iterations for n = 3 or 4 to build intuition.
Identify the pattern: Ask: Is it sequential or nested? Does the variable halve? Are there recursive calls?
Write the recurrence (for recursion): Express T(n) in terms of smaller subproblems, then solve using a recursion tree or Master Theorem.
Check edge cases: What if input sizes differ (m vs. n)? What if a loop runs a constant number of times?

Common Mistakes to Avoid

Forgetting to drop constants: O(n²/2) is still O(n²).
Miscounting triangular loops: j starting at i+1 still yields O(n²).
Assuming all recursion is exponential: Halving the input (like in merge sort) gives O(n log n), not O(2ⁿ).
Ignoring different input sizes: Nested loops over arrays of length m and n give O(mn), not O(n²).
Overlooking amortized analysis: Some loops with inner while-loops are still O(n) if each element is processed a bounded number of times.

Next Steps

Once comfortable with these problems, challenge yourself with:

Space complexity analysis: How much extra memory does the algorithm use?
Best, average, and worst-case analysis: When does an algorithm perform optimally or poorly?
Amortized analysis: Understand why some seemingly expensive operations average out to O(1).
Master Theorem: A powerful tool for solving recurrences of the form T(n) = aT(n/b) + f(n).

Practice consistently, and soon you'll be able to glance at any code snippet and instantly determine its time complexity.

Big O Notation Practice Problems with Solutions

2026-09-06T02:29:23.622+05:30

Big O notation describes how the running time or space requirements of an algorithm grow as the input size n increases. This guide contains Big O practice problems ranging from beginner to advanced, with step-by-step solutions and explanations.

Big O notation? Big O notation describes how the running time or space requirements of an algorithm grow as the input size n increases. This guide contains Big O practice problems ranging from beginner to advanced, with step-by-step solutions and explanations.

Complexity	Common example
O(1)	Array access
O(log n)	Binary search
O(n)	Linear search
O(n log n)	Merge sort
O(n²)	Nested loops
O(2ⁿ)	Some recursive algorithms

O(1) O(log n) O(n) O(n log n) O(n²) O(2ⁿ)

n = 64 : (1, log₂n, n) = (1, 6, 64)

(n log₂n, n²) = (384, 4,096)

2ⁿ = 1.84 × 10¹⁹

4 8 16 32 64

Problem 1: Constant Time O(1)

bool checkEven(int n) {
    return n % 2 == 0;
}

def check_even(n):
  return n % 2 == 0

Question: What is the time complexity?

Solution: O(1)

Explanation: “Inside the function, a constant number of operations is performed: the modulus operation (% 2) and a comparison (== 0). The number of operations does not depend on the size of the input numbum (n).

Problem 2: Linear Time O(n)

#include 
#include 

void printItems(const std::vector& arr) {
    for (int item : arr) {
        std::cout << item << "\n";
    }
    for (int item : arr) {
        std::cout << item << "\n";
    }
}

def print_items(arr):
  for item in arr:
    print(item)
  for item in arr:
    print(item)

Question: What is the time complexity?

Solution: O(n)

Explanation: The function loops through the list of n elements twice. This gives 2n steps. Big O notation drops constant coefficients, so 2n simplifies to O(n).

Problem 3: Logarithmic Time (O(log n))

int i = 1;
while (i < n) {
    i = i * 2;
}

i = 1
while i < n:
  i = i * 2

Question: What is the time complexity?

Solution: $O(\log n)$

Explanation: The complexity is $O(\log n)$ because the variable i doubles in each iteration, scaling logarithmically relative to n.
Problem 4: Quadratic Time O(n²)

#include int findPairs(const std::vector& numbers, int target_sum) { int count = 0; int n = numbers.size(); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (numbers[i] + numbers[j] == target_sum) { count++; } } } return count; }

def find_pairs(numbers, target_sum): count = 0 for i in range(len(numbers)): for j in range(len(numbers)): if numbers[i] + numbers[j] == target_sum: count += 1 return count

Question: What is the time complexity?

Solution: O(n²)

Explanation: Featuring nested loops where each individual loop runs n times, the total operations scale to $n^{2}$ while constant-time work occurs inside

Toll Tax Collection Computer Graphics Project in OpenGL

2026-08-23T00:06:16.876+05:30

The Toll Tax Collection Booth Simulation is a popular Computer Graphics mini-project developed using C/C++ with the GLUT/OpenGL library. The project creates a simple interactive highway environment where vehicles move through toll booths, stop at barriers, and continue once the gates are opened.

Key Project Features
Welcome Screen: Displays the project title, student details, and basic instructions for operating the simulation.
Dual-Lane Highway: Represents a two-way highway with separate lanes and toll booths for vehicles traveling in opposite directions.
Interactive Barriers: Vehicles automatically stop when they reach a toll booth. The user can manually raise the barrier to allow the vehicle to pass.
Dynamic Vehicle Control: Users can adjust vehicle speed and manage traffic using predefined keyboard controls.
Interactive Environment: Keyboard inputs make the simulation more engaging by allowing the user to control vehicle movement and toll barriers in real time.
Overall, the project demonstrates fundamental computer graphics concepts such as 2D object drawing, animation, transformations, user interaction, and keyboard-based controls in an easy-to-understand highway toll booth simulation.

🚧 Toll Tax Collection Computer Graphics Project User Controls

Action Left / Top Lane Right / Bottom Lane

Open Toll Barrier L / l R / r

Increase Speed Z / z V / v

Complete Source Code Implementation
You can compile and run this full working program using CodeBlocks, Visual Studio, or a standard GCC/Clang compiler with GLUT linked.
Step-by-Step Execution Guide
To run this project seamlessly on your computer, follow these setup stages:
Setup IDE: Open CodeBlocks or your environment of choice and start a new GLUT project.
Library Linking: Ensure your compiler options are linking the required dependencies: -lglut -lGLU -lGL.
Overwrite Main File: Replace all auto-generated code inside main.cpp with the script written above.
Compile: Hit Build and Run. Tap ENTER on the welcome screen to launch into the toll layout!

Full Source Code

#include #include #include // Global State Variables int screenMode = 0; // 0 = Welcome Screen, 1 = Toll Simulation float car1X = -250.0f, car2X = 250.0f; float speed1 = 2.0f, speed2 = 2.0f; bool gate1Open = false, gate2Open = false; float gate1Angle = 0.0f, gate2Angle = 0.0f; // Utility to render text strings void renderText(float x, float y, void* font, const char* string) { glRasterPos2f(x, y); for (int i = 0; i < strlen(string); i++) { glutBitmapCharacter(font, string[i]); } } // Renders the initial introduction screen void drawWelcomeScreen() { glClearColor(0.1f, 0.1f, 0.2f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0f, 1.0f, 1.0f); renderText(-120, 150, GLUT_BITMAP_HELVETICA_18, "COMPUTER GRAPHICS MINI PROJECT"); glColor3f(0.4f, 1.0f, 0.4f); renderText(-110, 100, GLUT_BITMAP_TIMES_ROMAN_24, "TOLL COLLECTING BOOTH SIMULATION"); glColor3f(0.9f, 0.9f, 0.3f); renderText(-200, 20, GLUT_BITMAP_HELVETICA_12, "CONTROLS:"); renderText(-200, 0, GLUT_BITMAP_HELVETICA_12, " 'L' / 'l' : Open Left Gate Barrier"); renderText(-200, -20, GLUT_BITMAP_HELVETICA_12, " 'R' / 'r' : Open Right Gate Barrier"); renderText(-200, -40, GLUT_BITMAP_HELVETICA_12, " 'Z' / 'z' : Speed up Left Car"); renderText(-200, -60, GLUT_BITMAP_HELVETICA_12, " 'V' / 'v' : Speed up Right Car"); glColor3f(0.3f, 0.8f, 1.0f); renderText(-90, -130, GLUT_BITMAP_HELVETICA_14, "Press [ENTER] to Launch Simulation"); glutSwapBuffers(); } // Renders the main simulation scene void drawSimulationScene() { glClearColor(0.2f, 0.5f, 0.2f, 1.0f); // Green background for fields glClear(GL_COLOR_BUFFER_BIT); // 1. Draw Two-Way Road Asphalt glColor3f(0.2f, 0.2f, 0.2f); glBegin(GL_QUADS); glVertex2f(-300, 80); glVertex2f(300, 80); glVertex2f(300, -80); glVertex2f(-300, -80); glEnd(); // 2. Draw Yellow Center Divider Line glColor3f(1.0f, 1.0f, 0.0f); glLineWidth(3.0); glBegin(GL_LINES); glVertex2f(-300, 0); glVertex2f(300, 0); glEnd(); // 3. Draw Toll Cabins // Left Cabin glColor3f(0.7f, 0.1f, 0.1f); glBegin(GL_QUADS); glVertex2f(-60, 120); glVertex2f(-20, 120); glVertex2f(-20, 80); glVertex2f(-60, 80); glEnd(); // Right Cabin glBegin(GL_QUADS); glVertex2f(20, -80); glVertex2f(60, -80); glVertex2f(60, -120); glVertex2f(20, -120); glEnd(); // 4. Draw Left Lane Gate Barrier glPushMatrix(); glTranslatef(-20, 40, 0); glRotatef(gate1Angle, 0, 0, 1); glColor3f(1.0f, 0.5f, 0.0f); glLineWidth(6.0); glBegin(GL_LINES); glVertex2f(0, 0); glVertex2f(0, 40); glEnd(); glPopMatrix(); // 5. Draw Right Lane Gate Barrier glPushMatrix(); glTranslatef(20, -40, 0); glRotatef(-gate2Angle, 0, 0, 1); glColor3f(1.0f, 0.5f, 0.0f); glLineWidth(6.0); glBegin(GL_LINES); glVertex2f(0, 0); glVertex2f(0, 40); glEnd(); glPopMatrix(); // 6. Render Car 1 (Moving Left to Right) glColor3f(0.1f, 0.4f, 0.8f); glBegin(GL_QUADS); glVertex2f(car1X, 60); glVertex2f(car1X + 40, 60); glVertex2f(car1X + 40, 20); glVertex2f(car1X, 20); glEnd(); // 7. Render Car 2 (Moving Right to Left) glColor3f(0.8f, 0.1f, 0.2f); glBegin(GL_QUADS); glVertex2f(car2X, -20); glVertex2f(car2X - 40, -20); glVertex2f(car2X - 40, -60); glVertex2f(car2X, -60); glEnd(); glutSwapBuffers(); } // Master display routing void display() { if (screenMode == 0) { drawWelcomeScreen(); } else { drawSimulationScene(); } } // Handles frame state updates and simulation arithmetic void update(int value) { if (screenMode == 1) { // Handle Left Car Stopping / Moving Logic if (!gate1Open && (car1X + 40 >= -60) && (car1X < -60)) { car1X = -100; // Force full stop at booth entry boundary } else { car1X += speed1; if (car1X > 300) { // Loop back around car1X = -300; gate1Open = false; } } // Handle Right Car Stopping / Moving Logic if (!gate2Open && (car2X - 40 <= 60) && (car2X > 60)) { car2X = 100; // Force full stop at booth entry boundary } else { car2X -= speed2; if (car2X < -300) { // Loop back around car2X = 300; gate2Open = false; } } // Smoothly animate gate positions if (gate1Open && gate1Angle < 90.0f) gate1Angle += 5.0f; if (!gate1Open && gate1Angle > 0.0f) gate1Angle -= 5.0f; if (gate2Open && gate2Angle < 90.0f) gate2Angle += 5.0f; if (!gate2Open && gate2Angle > 0.0f) gate2Angle -= 5.0f; } glutPostRedisplay(); glutTimerFunc(16, update, 0); // Roughly 60 Frames Per Second } // Configures coordinate projections void reshape(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(-300, 300, -200, 200); glMatrixMode(GL_MODELVIEW); } // User Input Evaluator void keyboard(unsigned char key, int x, int y) { switch (key) { case 13: // ENTER key screenMode = 1; break; case 'L': case 'l': gate1Open = true; break; case 'R': case 'r': gate2Open = true; break; case 'Z': case 'z': speed1 += 0.5f; break; case 'V': case 'v': speed2 += 0.5f; break; case 27: // ESC key exit(0); break; } } int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(800, 600); glutCreateWindow("OpenGL Toll Booth Simulation"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutTimerFunc(0, update, 0); glutMainLoop(); return 0; }

OpenGL Python Program for Rendering Poké Ball

2026-06-17T01:46:55.559+05:30

1. Render a Normal 3D Poké Ball

The Poké Ball itself is usually just a sphere mesh with:

A red upper hemisphere

A white lower hemisphere

A black center band

A circular button on the front

The geometry can be:

A UV sphere

An icosphere

A procedurally generated sphere

The fragment shader might assign colors based on position:

if (worldPos.y > 0.0)
    color = vec3(1.0, 0.0, 0.0); // red
else
    color = vec3(1.0);            // white

The black band can be created using latitude calculations or a separate mesh.

2. Use Low-Resolution Rendering

A common pixel-art trick is rendering to a small framebuffer first.

For example:

320 x 180

instead of:

1920 x 1080

The scene is rendered into an off-screen texture (FBO).

Then that texture is stretched to the screen using:

GL_NEAREST

filtering.

This creates large visible pixels.

glTexParameteri(
    GL_TEXTURE_2D,
    GL_TEXTURE_MIN_FILTER,
    GL_NEAREST
);

3. Quantized Lighting

Instead of smooth lighting:

float diffuse = max(dot(N, L), 0.0);

you reduce it to a few discrete levels.

Example:

float diffuse = max(dot(N, L), 0.0);

diffuse = floor(diffuse * 4.0) / 4.0;

This produces only 4 brightness levels.

Result:

Bright region

Mid-bright

Mid-dark

Dark

Very similar to retro sprite shading.

4. Palette Reduction

Pixel-art renderers often limit colors intentionally.

Example:

vec3 color = baseColor * diffuse;

color = floor(color * 8.0) / 8.0;

This converts continuous colors into a small palette.

Instead of thousands of shades, you might have:

8 reds

8 grays

8 blacks

giving a classic pixel-art appearance.

5. Pixel Grid Snapping

Many projects quantize screen coordinates.

Example:

vec2 pixelSize = vec2(4.0);

vec2 snappedUV =
    floor(gl_FragCoord.xy / pixelSize)
    * pixelSize;

All fragments within a block sample the same value.

This creates chunky pixels even when rendering at higher resolutions.

6. Dithering

To fake additional colors, retro-style renderers often use dithering.

Common patterns:

Bayer Matrix

0 8 2 10
12 4 14 6
3 11 1 9
15 7 13 5

Shader:

if(diffuse < threshold)
    color *= 0.8;

This creates the checkerboard patterns often seen in pixel art.

7. Outline Rendering

Many stylized renders add outlines.

Two common methods:

Inverted Hull

Render the model twice:

Normal render

Render enlarged backfaces in black

position += normal * 0.02;

Produces a cartoon outline.

Edge Detection

Run a post-process pass using:

Depth buffer

Normal buffer

Detect sharp changes and draw black edges.

8. Shadow Quantization

If the image has sharp, stylized shadows, they may use toon shading:

if(diffuse > 0.7)
    shade = 1.0;
else if(diffuse > 0.4)
    shade = 0.7;
else
    shade = 0.3;

Instead of smooth gradients, you get discrete shadow bands.

9. Specular Highlights

The shiny white highlight on the Poké Ball can be stylized:

float spec =
    pow(max(dot(R, V), 0.0), 32.0);

spec = step(0.5, spec);

Using step() creates a hard-edged highlight instead of a realistic glossy reflection.

10. Typical Rendering Pipeline

A common pipeline would be:

Sphere Mesh
      ↓
Vertex Shader
      ↓
Toon Lighting
      ↓
Palette Reduction
      ↓
Render to Low-Res FBO
      ↓
Nearest Neighbor Upscaling
      ↓
Dithering Pass
      ↓
Display

The characteristic "3D object that looks like pixel art" usually comes primarily from:

Rendering to a very low-resolution framebuffer

Nearest-neighbor upscaling

Quantized (toon) lighting

Palette reduction

Optional dithering and outlines

Those five techniques together can make a smooth 3D OpenGL model look remarkably similar to hand-drawn pixel art while still being fully real-time and rotatable.
It can be generate via below mentioned stacks -
PyOpenGL + GLFW (closest to modern OpenGL tutorials)
PyOpenGL + Pygame
moderngl (cleaner Python API, often easier)
Pyglet

Ursina (higher-level engine)

Google Doc 7 KB

Artificial intelligence and OpenGL

2026-05-16T01:42:09.679+05:30

Artificial intelligence and OpenGL work together to create graphics and interactive systems. OpenGL is a graphics tool that lets programs draw pictures by talking to the computers graphics card. Artificial intelligence adds intelligence by generating pictures improving how things are drawn and driving behavior in time.
For someone who just graduated there are some examples. Artificial intelligence can generate textures, meshes and environments. This means you do not have to make every picture by hand. Artificial intelligence can produce high-quality textures. Suggest simpler meshes that still look good but are easier to make. When it comes to drawing pictures artificial intelligence techniques like denoising and superresolution help make clean pictures faster. Artificial intelligence removes noise from pictures. Makes them bigger and OpenGL shows the final picture efficiently.
Artificial intelligence also makes things more interactive. It can teach characters to move naturally in scenes that follow physics rules. Artificial intelligence can also create motion without needing to set lots of key frames. On the performance side artificial intelligence can predict which objects need to look really detailed and which can be simpler. This helps programs run smoothly on computers that're not very powerful.
As someone who's new to this field you should focus on learning the basics of OpenGL, such as shaders, buffers and textures. You should also study how artificial intelligence is used in real-world applications like using neural networks for pictures and small models for real-time use. Some challenges you might face include managing latency and memory for models and making sure the artificial intelligence output looks the way you want it to. If you master both OpenGL and artificial intelligence you can have a career, in game engines, simulation and real-time graphics tools.
Advances in graphics and artificial intelligence (AI) are changing many parts of our lives—from how cars learn to drive, to how doctors see inside the body, to the games we play. OpenGL-style graphics APIs and modern GPU-based rendering create realistic visual worlds, while AI analyzes those visuals to make decisions, find patterns, or create new content. Below are five important ways these two technologies collaborate in the real world.
Self-Driving Car Simulation

Self-driving cars need huge amounts of visual experience to learn safe driving. Companies such as NVIDIA use GPU rendering similar to OpenGL to generate realistic 3D scenes that include roads, traffic, lighting, pedestrians, and weather. These simulated environments give AI systems—using computer vision and reinforcement learning—safe and repeatable places to practice. From these training sessions, AI learns tasks like lane detection, recognizing pedestrians, and understanding traffic signs. Key technologies behind this work include OpenGL or Vulkan for rendering, neural networks for perception and decision-making, and GPU acceleration tools such as CUDA and TensorRT for fast model training and inference.
AI-Powered Medical Imaging

Medical teams use powerful graphics and AI to improve diagnosis and planning. OpenGL-style rendering helps visualize MRI and CT scans as interactive 3D views of organs and tissues, making it easier for doctors to explore inside the body. AI analyzes those images to detect tumors, fractures, or other abnormalities automatically. Together, these tools support cancer detection, surgical planning, and organ reconstruction. Major companies working in this area include Siemens Healthineers and GE HealthCare, which combine advanced visualization with AI-driven image analysis.
Modern Video Games

Video games blend rendering and AI to create immersive, believable worlds. Graphics APIs render environments, shadows, particles, and animations, while AI controls non-player characters (NPCs), plans enemy tactics, generates landscapes procedurally, and improves visuals through real-time upscaling. This combination creates smarter enemies, AI-generated terrain, and better real-time lighting or ray-reconstruction effects. Popular engines and games that use these ideas include Unity, Unreal Engine, and titles like Minecraft that demonstrate procedural generation and AI-driven behaviors.
AI + OpenGL in Robotics

Robots must perceive and navigate complex spaces. OpenGL-style rendering is used to build virtual training environments where AI vision systems learn tasks such as navigation, object detection, and motion planning. Simulated practice helps robots prepare for real-world jobs like warehouse picking, drone navigation, and industrial automation without risking hardware. Companies such as Boston Dynamics and Open Robotics develop robotic systems that rely on simulation and AI to improve reliability and safety.
AI Face Filters & Augmented Reality Applications

Augmented reality (AR) apps combine graphics with AI to create fun and useful effects on mobile devices. OpenGL ES renders masks, makeup, and other visual effects in real time, while AI tracks facial landmarks and expressions to place those effects accurately. These systems power features like face filters, virtual makeup, AR gaming, and motion capture in apps such as Instagram and Snapchat, enabling smooth, responsive visuals that react to users’ movements.
Conclusion

OpenGL-style graphics and AI form a powerful partnership: rendering produces realistic visuals and simulations, while AI interprets or enhances those visuals to perform tasks, make decisions, or create new content. Together, they accelerate innovation in autonomous vehicles, healthcare, gaming, robotics, and augmented reality—fields that students interested in computer graphics, machine learning, or robotics might consider exploring.

Animated University Campus Using OpenGL GLUT

2026-05-16T01:23:25.725+05:30

Animated University Campus Using OpenGL & C++.
Learn Computer Graphics by Building a Real Animated Campus Scene.

Project Introduction

Computer Graphics is one of the most exciting areas of programming because it allows us to create visual worlds using code. In this project, we developed a fully animated university campus scene using OpenGL with GLUT in C++. The project demonstrates how basic graphics primitives such as polygons, circles, and lines can be combined to create an interactive animated environment.

Project Overview

In this project, we created a fully animated university campus using OpenGL with GLUT in C++.

The scene includes buildings, football ground, moving vehicles, animated students, birds, rain effects, day/night mode, and several interactive graphics features.

Features Included

The campus simulation includes:

A large university building

Football Ground with Goal Posts

Animated Students

Moving Cars and Buses

Flying Airplane

Rain Effect

Day and Night Mode

Animated White Flag

Trees and park area

University Gate

Fountain Animation

Birds and Clouds

User interaction using keyboard controls

This project is ideal for beginners who want to learn:

OpenGL fundamentals

2D graphics drawing

Animation techniques

Event handling

User interaction

Real-time rendering

Technologies Used

C++

OpenGL

GLUT (OpenGL Utility Toolkit)

Understanding the Graphics Concepts

1. Drawing Shapes

OpenGL uses vertices to create graphics objects. Rectangles, polygons, and circles are combined to create buildings, roads, vehicles, and trees.

glBegin(GL_QUADS); glVertex2f(x,y); glVertex2f(x+80,y); glVertex2f(x+80,y+25); glVertex2f(x,y+25);

2. Animation

Animation is achieved by updating object positions continuously using timer functions.

planeMove += 1.5f; carMove += 2.0f; glutTimerFunc(16, update, 0);

3. Interactive Controls

Keyboard controls allow users to interact with the scene.

case 'n': nightMode = !nightMode; break;

Keyboard Controls

Key Action

N Toggle Night Mode

R Toggle Rain

B Toggle Bus

C Toggle Cars

P Toggle Plane

ESC Exit Program

Learning Outcomes

After completing this project, students will learn:

2D Graphics Programming

OpenGL Rendering

Animation Techniques

Interactive Graphics

Keyboard Event Handling

Coordinate Systems

Scene Design

Future Improvements

3D Buildings

Traffic Lights

Sound Effects

Weather Systems

Character Controls

Texture Mapping

Lighting Effects

OpenGL Project Applications

OpenGL is widely used in modern software development for:

Game Development

Simulation Systems

Scientific Visualization

Virtual Reality Applications

CAD Software

Animation Systems

Educational Simulations

Interactive User Interfaces

By building this animated campus environment, students gain practical understanding of how real-world graphics applications are developed.

Conclusion

This OpenGL campus simulation project is a great way to learn computer graphics through practical implementation.

By combining shapes, animation, interaction, and rendering, students can build impressive graphical applications using C++.

Continue experimenting and improving the project to explore more advanced computer graphics concepts.

Best OpenGL Project for Beginners

If you are searching for a beginner-friendly OpenGL project in C++, this animated campus simulation is an excellent choice. It combines graphics rendering, animation, interaction, and scene management into one practical project.

This project is especially useful for:

Computer Graphics Lab Projects

University Assignments

Final Year Projects

OpenGL Practice

C++ Animation Learning

Graphics Programming Portfolio

Frequently Asked Questions (FAQ)

What is OpenGL?

OpenGL is a cross-platform graphics library used for developing 2D and 3D graphics applications.

What is GLUT?

GLUT (OpenGL Utility Toolkit) helps developers create OpenGL windows and handle user interactions like keyboard and mouse events.

Can beginners learn this project?

Yes. This project is beginner-friendly and helps students understand graphics programming step by step.

Which language is used?

The project is developed using C++ with OpenGL and GLUT.

Info!
OpenGL Campus Project Tutorial Learn OpenGL graphics programming with practical examples, animated projects, C++ tutorials, and interactive computer graphics concepts.

Keywords: OpenGL project, computer graphics tutorial, GLUT animation, C++ graphics programming, OpenGL campus simulation, beginner OpenGL project.

Importance of insurance - OpenGL Computer Graphics Projects

2026-05-11T01:10:56.984+05:30

The Importance of Insurance – OpenGL Computer Graphics Project is a computer graphics-based project developed using OpenGL (Open Graphics Library) to visually demonstrate the concept and importance of insurance. The main purpose of the project is to combine programming and computer graphics to create an interactive and attractive representation of different insurance concepts.

I nsurance is an important part of financial planning because it provides protection against unexpected risks such as accidents, health problems, property damage, and other unforeseen events. Instead of explaining these concepts only through text, this project presents them using 2D/3D graphical objects, animations, colors, text, and user interaction.

Objective of the Project

The primary objective of this project is to develop an OpenGL-based graphical application that explains the importance of insurance in an easy-to-understand manner.

The project aims to:

Demonstrate the concept of insurance through computer graphics. Present different types of insurance using visual elements. Show how insurance provides financial protection during unexpected situations. Develop an interactive graphical application using OpenGL. Apply fundamental computer graphics concepts such as shapes, transformations, colors, text rendering, and animation. Improve understanding of OpenGL programming through a practical project.

Project Description

The project consists of a graphical interface in which different insurance-related scenarios are represented visually. The application can display elements such as a house, car, hospital, family, money, documents, and protection symbols to represent various types of insurance.

Why Insurance Matters
Insurance provides financial protection, peace of mind, and security for your family during uncertain times. It helps you stay prepared for life’s unexpected challenges.

Benefits of Life Insurance

Life insurance protects your loved ones financially in case of emergencies. It provides income replacement, supports children’s education, and ensures your family can maintain their lifestyle.

Ensures your family remains financially secure after your absence.

Helps cover loans, expenses, and future commitments.

Reduces financial pressure during difficult moments.

Allows you to leave behind support for future generations.

Who Needs Insurance?

Insurance is important for parents, homeowners, business owners, and anyone with financial responsibilities. It protects families, assets, and future goals.

Importance of Insurance for Everyone

Insurance is not just a policy — it is a safety net that protects your dreams and hard work. From medical emergencies to financial planning, insurance secures a stable future.

“”

Insurance is a small investment for a secure tomorrow. Protect yourself, your family, and your future with the right coverage.
Anonymous

Why Buy Term Insurance?

Term insurance offers high coverage at affordable premiums. It protects dependents financially and safeguards your future goals.

Affordable Premiums

Get large coverage at a lower cost.

Protect Dependents

Ensures your family can manage expenses after your loss.

Asset Protection

Helps preserve savings and investments.

Life Goal Support

Supports future goals like education and stability.

Get large coverage at a lower cost.

Ensures your family can manage expenses after your loss.

Helps preserve savings and investments.

Supports future goals like education and stability.

End of Article OpenGL Computer Graphics Project
Download Source Code

BATMAN OPENGL COMPUTER GRAPHICS PROJECT USING C++ | With Source Code and Report

2026-05-11T00:52:45.385+05:30

OpenGL Project (C++ + GLUT)
This project is a simple 2D graphics application made using:

C++

OpenGL

GLUT (OpenGL Utility Toolkit)

OBJECTIVE
The main objectives of the project are:

To understand OpenGL graphics programming

To implement 2D graphics using C++

To create animations using timer functions

To learn keyboard interaction handling

To design multiple graphical scenes
TECHNOLOGIES USED

1. C++

Used for implementing program logic and graphics functions.

2. OpenGL

Used for rendering graphics objects.

3. GLUT

Used for:

Window handling

Keyboard interaction

Timer functions

Display management
WORKING OF THE PROJECT

The program starts with the introduction screen.

User presses N to move between scenes.

Gotham city scene displays animated moon movement.

Batman scene displays Batman standing on a building.

Logo scene displays rotating Batman logo.

Thank you screen is displayed at the end.

OUTPUT SCREENS
Scene 1
College Intro Screen
Scene 2
Animated Gotham City
Scene 3
Batman Standing on Building
Scene 4
Rotating Batman Logo
Scene 5
Thank You Screen
ADVANTAGES

Simple and easy to understand

Demonstrates OpenGL basics

Includes animation and transformations

Interactive graphics application

Useful for learning computer graphics

LIMITATIONS

Uses only 2D graphics

Basic Batman design

No sound effects

Limited animation
DESIGN AND IMPLEMENTATION

Batman is one of the world's most iconic fictional superheroes, appearing in American comic books published by DC Comics. Created by artist Bob Kane and writer Bill Finger.

Header Files
Headaer Files used in for desing and implementation of BATMAN OPENGL COMPUTER GRAPHICS PROJECT USING C++ are -

1.#include <GL/glut.h> - For OpenGL functions and graphics creation and user interations
2. #include <cmath> - Used for:

sin()

cos()

Needed for circles and rotation.
3. #include <cstring> -

Used for:

strlen()

Needed to print text character by character.
Global Variables :
scene is used a global varaiable for Controls current screen. with keyboard functions assigned for user to shift between the screense
scene

Controls current screen.
The program displays:

College intro screen

Gotham city animation

Batman standing on building

Rotating Batman logo

Thank you screen
Value Scene
0 Intro
1 Gotham City
2 Batman
3 Logo
4 Thank You

Changes:
true → false
false → true
Used for blinking text.

Drawing Circle
void drawCircle(float cx, float cy, float r)
Used for:

Moon

Batman head

Eyes
Creates city buildings using rectangles.

and similarly other polygons are use to create building logo and batman body etc.
Timer Function (Animation)

void timer(int)
{
moonX += 0.002f;

if (moonX > 1.2f)
moonX = -1.2f;

logoAngle += 2.0f;

if (logoAngle > 360)
logoAngle = 0;

blink = !blink;

glutPostRedisplay();
glutTimerFunc(30, timer, 0);
}

glutTimerFunc(30, timer, 0);

Calls timer again every 30 milliseconds.

This creates animation.

IMPORTANT OPENGL FUNCTIONS

Function Purpose
glBegin() Start drawing
glEnd() End drawing
glVertex2f() Define point
glColor3f() Set color
glClear() Clear screen
glFlush() Show drawing
glRotatef() Rotate object
glTranslatef() Move object
glPushMatrix() Save position
glPopMatrix() Restore position
User Interactions

Keyboard Function void keyboard(unsigned char key, int x, int y) is used as user interations with scence as said above -

Key - Interaction

'n' - Next Scene

'p' - Previous Scene

ESC -> Exit
CONCLUSION

The project successfully demonstrates the implementation of computer graphics concepts using OpenGL and C++.
It helps in understanding:

Graphics rendering

Animation

Scene management

User interaction

The project is useful for beginners to learn OpenGL programming concepts practically.
HOW TO IMPROVE PROJECT

1. Add More Animation

Ideas

Batman walking

Moving cape

Flashing bat signal

Rain effect

Flying bats

2. Add Sound

Use Batman music.

Windows:

PlaySound(TEXT("batman.wav"), NULL, SND_ASYNC);

3. Add Stars

Draw small white circles.

Creates realistic night sky.

4. Add Color Gradients

Instead of plain background:

Dark blue top

Black bottom

Looks professional.

5. Improve Batman Shape

Add:

Arms

Gloves

Belt

Boots

Better face

6. Add More Buildings

Currently only few buildings.

Add:

More towers

Antennas

Windows with blinking lights

7. Use Double Buffering

Current:

GLUT_SINGLE

Better:

GLUT_DOUBLE

Then:

glutSwapBuffers();

Benefits:

Smooth animation

No flickering

8. Add Mouse Interaction

Example:

Click to switch scenes

Click logo to rotate faster

9. Add Day/Night Mode

Press:

D → Day

N → Night

10. Add 3D OpenGL

Advanced improvement:

3D Batman logo

Lighting

Shadows

Camera movement

Recommended Viva Explanation

If teacher asks:
“How does animation work?”

Answer:

Animation is created using glutTimerFunc().
It repeatedly updates variables like moon position and logo rotation angle, then redraws the scene continuously.

If teacher asks:
“How is Batman drawn?”

Answer:

Batman is created using basic OpenGL primitives such as polygons, triangles, and circles.

If teacher asks:
“How does scene switching work?”

Answer:

A global variable called scene stores the current scene number. Keyboard input changes the value, and the display function draws different scenes accordingly.

Source Code Downloads
BATMAN OPENGL COMPUTER GRAPHICS PROJECT USING C++ Free Source code download

Pi Day: Where Math Meets a Slice of Fun

2026-03-14T18:55:00.002+05:30

Every year on March 14 (3/14), all the math lovers around the world celebrate Pi Day —as a tribute to the mathematical constant π (pi). The Value of Pi is 3.14. upto two decimal place. As these may be slipt to 3 and 14 represeting 3 as march month and 14 as date, hence PI DAY. This quirky holiday blends geeky fun with delicious pies, making math feel less intimidating and more indulgent.
Also the Value of Pi is long ending with each mathematician has cacluate to some extent of decimal places. The Pi represents the ratio of a circle’s circumference to its diameter and appears in countless formulas, theorem, thesis etc and used in various feilds including science, engineering, and technology. PI being an infinite and non-repeating number, it has become one of the most famous constants in mathematics.

When it statrtd PI DAY?

Today is Pi Day, celebrated on March 14 (or 3.14) to honor the mathematical constant π.
Interestingly, Pi Day began in 1988 at the Exploratorium in San Francisco, where physicist Larry Shaw organized the first celebration. Over time, the tradition spread worldwide and even gained official recognition in the United States in 2009.
The Story of Origin: 1988 At the San Francisco Exploratorium, Pi Day was first officially observed. It was created by Larry Shaw, a physicist known as the "Prince of Pi." Shaw selected March 14 (3/14) as the date because it corresponds to the first three digits of the mathematical constant: 3.14. The Ritual: Shaw and his employees marched around one of the museum's circular areas as part of the first celebration, after which they ate a lot of fruit pies.The Logistics: Shaw discovered that "pi" and "pie" are homophones in addition to pies are—conveniently—circular in a flash of insight (or maybe just hunger).The Celebration's Development What was once a specialized staff party swiftly became a worldwide sensation.
Today, enthusiasts recite its endless digits, bake π-themed pies, and share memes poking fun at its irrational nature. In 2026, social media buzzes with crypto twists and cat-in-chef-hat antics, turning classrooms into pie parties.
One of the reasons Pi Day is so popular is the endless supply of math jokes and memes. After all, when a mathematical constant sounds exactly like a dessert, the internet can’t resist. You’ll often see jokes like: “It’s okay, Pi Day is all about the pie!”—a reminder that sometimes learning math can be both educational and delicious.
So whether you’re a mathematician, a student, or just someone who enjoys dessert, Pi Day is a perfect reminder that math can be fun, creative, and surprisingly tasty.
Google PI Day Doodle
Google has dedicate 14/03/2026 PI Day with a good mathematical Doodle as given -

Google created a unique interactive Doodle in celebration of the ancient Greek mathematician Archimedes and his groundbreaking technique for determining the limits of pi in commemoration of Pi Day in 2026.

And remember: if anyone asks why you’re eating pie on March 14, just say it’s for educational purposes. 😄
Why not join in? Grab a slice of apple pie, ponder infinity, and remember: even Einstein would approve. Pi reminds us circles are endless—and so is the joy in a good pun. Happy Pi Day! (198 words) PI Day Video for you -https://www.youtube.com/shorts/ZWlDDm_R_HQ

Top 20 OpenGL Projects for Engineering Students

2026-03-05T03:13:00.002+05:30

ABSTRACT
Computer graphics plays an important role in fields such as gaming, simulation, visualization, and scientific computing. OpenGL is one of the most widely used graphics APIs for building cross-platform graphics applications. Through practical projects, engineering students can gain a deeper understanding of rendering pipelines, GPU programming, shaders, and 3D mathematics.
This report presents twenty OpenGL project ideas categorized by difficulty level, including beginner, intermediate, and advanced projects. Each project is designed to strengthen practical skills in modern graphics programming using C++ and OpenGL. The goal of these projects is to help students develop the ability to design and implement real-time graphics applications.
TABLE OF CONTENTS
Introduction
Objectives
Development Tools and Technologies
Beginner-Level OpenGL Projects
Intermediate-Level OpenGL Projects
Advanced-Level OpenGL Projects
Applications of OpenGL Projects
Conclusion
References

1. INTRODUCTION
OpenGL (Open Graphics Library) is an industry-standard graphics API used for developing two-dimensional and three-dimensional graphics applications. It provides developers with the tools needed to control the GPU and implement efficient rendering pipelines.
In modern computer graphics education, practical implementation is essential. Students must understand how rendering works through real projects that demonstrate concepts such as:
Vertex processing
Lighting models
Texture mapping
Shader programming
Real-time rendering techniques
The following project list is structured to help engineering students progressively build their skills from fundamental graphics programming to advanced rendering systems.
2. OBJECTIVES
The objectives of these OpenGL projects are:
To understand the fundamentals of computer graphics.
To develop practical experience with OpenGL programming.
To explore GPU-based rendering techniques.
To implement interactive graphics applications.
To prepare students for careers in graphics programming, game development, and simulation.
3. DEVELOPMENT TOOLS AND TECHNOLOGIES
The following tools are commonly used for OpenGL development.
Tool Purpose
OpenGL Graphics rendering API
C++ Primary programming language
GLFW Window creation and input handling
GLAD / GLEW OpenGL function loading
GLM Mathematics library
stb_image Texture loading
Assimp 3D model loading
Dear ImGui User interface for debugging
These libraries simplify the development of modern OpenGL applications.
4. BEGINNER-LEVEL OPENGL PROJECTS
These projects introduce the fundamental concepts of rendering and graphics programming.
4.1 2D Shape Drawing Application
This project allows users to draw basic geometric shapes such as:
Lines
Triangles
Rectangles
Circles
Concepts learned:
Vertex buffers
Rendering primitives
User input handling
4.2 Interactive Solar System Simulation
This project simulates planetary motion where planets revolve around the sun.
Features:
Orbital motion
Planet rotation
Keyboard-controlled camera
Concepts learned:
Hierarchical transformations
Rotation matrices
4.3 3D Cube Viewer
A simple program displaying a cube that can be rotated, scaled, and translated.
Concepts learned:
Model, View, Projection matrices
Basic camera system
4.4 Texture Mapping Demonstration
Render textured objects such as cubes or spheres.
Concepts learned:
UV coordinates
Texture sampling
Texture filtering
4.5 Basic 3D Model Viewer
Load and render a 3D model file.
Features:
Model loading
Lighting
Camera control
Concepts learned:
Mesh structures
Model rendering pipeline
5. INTERMEDIATE-LEVEL OPENGL PROJECTS
These projects introduce more advanced graphics techniques.
5.1 Real-Time Terrain Generator
Generate terrain using procedural methods such as noise functions.
Concepts learned:
Heightmaps
Procedural generation
5.2 3D Maze Navigation Game
A small game where the player navigates through a maze using a first-person camera.
Concepts learned:
Collision detection
Camera systems
Game logic
5.3 Particle System Simulation
Simulate visual effects such as fire, smoke, or rain.
Concepts learned:
Particle systems
GPU instancing
5.4 Shadow Mapping
Implement dynamic shadows in a scene.
Concepts learned:
Depth maps
Framebuffer objects
5.5 Physics-Based Bouncing Ball Simulation
Simulate objects bouncing under gravity.
Concepts learned:
Motion equations
Collision response
5.6 First-Person Camera System
Develop a camera system similar to those used in FPS games.
Features:
Mouse look
Keyboard movement
Perspective projection
5.7 Water Rendering Simulation
Render animated water surfaces.
Concepts learned:
Reflection
Refraction
Wave animation
6. ADVANCED-LEVEL OPENGL PROJECTS
These projects involve complex rendering algorithms and system design.
6.1 Real-Time Ray Tracing (Hybrid)
Implement basic ray tracing techniques using shaders.
Concepts learned:
Ray-object intersection
Reflection and shadow calculations
6.2 Deferred Rendering Engine
Build a rendering pipeline capable of handling multiple lights efficiently.
Concepts learned:
G-buffer rendering
Deferred shading
6.3 Procedural City Generator
Automatically generate buildings and urban layouts.
Concepts learned:
Procedural modeling
Scene generation
6.4 Cloth Simulation
Simulate cloth movement using physics models.
Concepts learned:
Mass-spring systems
Real-time simulation
6.5 GPU Fluid Simulation
Create a real-time fluid or smoke simulation.
Concepts learned:
Numerical simulation
Compute shaders
6.6 OpenGL Mini Game Engine
Develop a basic rendering engine supporting:
Scene management
Lighting systems
Model loading
Camera control
6.7 Augmented Reality Viewer
Integrate computer vision with OpenGL rendering.
Concepts learned:
Camera calibration
Marker tracking
3D overlay rendering
6.8 Virtual Reality Scene Viewer
Render stereoscopic scenes for VR headsets.
Concepts learned:
Stereo rendering
Head tracking integration
7. APPLICATIONS OF OPENGL PROJECTS
OpenGL-based systems are widely used in many industries:
Video game development
Scientific visualization
CAD and engineering software
Virtual reality systems
Simulation and training environments
Medical imaging visualization
Developing OpenGL projects prepares students for careers in these fields.
8. CONCLUSION
OpenGL projects provide engineering students with hands-on experience in computer graphics programming. By implementing progressively complex projects, students can develop a deep understanding of rendering pipelines, shader programming, and real-time graphics techniques.
These twenty projects offer a structured pathway from beginner concepts to advanced graphics development, helping students build a strong foundation in modern graphics programming.
9. REFERENCES
OpenGL Architecture Review Board. OpenGL Programming Guide.
Shreiner, Dave et al. OpenGL SuperBible.
Akenine-Möller, Tomas et al. Real-Time Rendering.
OpenGL Official Documentation.
Graphics programming tutorials and educational resources.

Space Shooter game built with OpenGL -18CSL67/21CSL66

2025-12-26T00:44:00.003+05:30

Students at Visvesvaraya Technological University (VTU) frequently engage in OpenGL mini-projects as a component of the Computer Graphics and Visualization (18CSL67/21CSL66) course. The newest initiatives for 2025 focus on interactive simulations and visual representations of algorithms.
A Space Shooter game built with OpenGL is a typical project for understanding computer graphics, usually developed in C++ language and utilizing well-known libraries such as GLFW, GLUT, and GLEW.
These games are typically 2D featuring traditional arcade-style mechanics and are frequently presented as assignments for courses in computer graphics and visualization.

Typical Attributes
2D Graphics: The game mainly employs 2D rendering, leveraging OpenGL to render points, lines, and polygons, which are subsequently textured to depict spaceships, bullets, and backgrounds.
Game Mechanics:
The gamer navigates a spacecraft around the display (typically using 'W', 'S', 'A', 'D' or 'I', 'K', 'J', 'L' buttons) and fires at foes with designated keys.
Enemies may consist of standard minions and bosses that have health bars.
Collision detection is an essential aspect, frequently employing Axis-Aligned Bounding Boxes (AABB) or circular/spherical detection, to identify when projectiles strike enemies or when the player takes damage.
Power-ups, like those that enhance fire rate or reduce boss health, might be obtainable.
Technical Execution:
The games frequently use a game loop for ongoing updates and rendering.
Libraries like stb_image are utilized for loading textures, while OpenAL is often selected for audio.
Fundamental shaders (color, texture, font) are generally applied.
Elements such as score trackers, health indicators, primary menus, and game over screens are also included in the user experience.
Coding Materials and Educational Tools
Many open-source projects can be found on GitHub, which can act as great educational tools or foundations for your own initiative.

Also See  Space Invaders Freeglut Project

Basic 2D Game: An uncomplicated execution in C++ and OpenGL for fundamental understanding.
Contemporary OpenGL Method: A more intricate endeavor focused on tidy code and contemporary OpenGL capabilities, featuring an extensive roadmap that includes elements such as collision detection, sound, and state machines.
Multiplayer Edition: A project that features a two-player game along with a menu and introductory system

Game Description
Keybord control for PLAYER 1 :
W - UP
S - DOWN
A - LEFT
D - RIGHT
C - to shoot, Use 'w' and 's' to change direction.
Keybord control for PLAYER 2 :
I - UP
K - DOWN
J - LEFT
L - RIGHT
M - to shoot, Use 'I' and 'K' to change direction.

Objective
kill your opponent.
Each time a player gets shot, LIFE decreases by 5 points.
Source Code - 1. Download Free 2. Alternate Download Source Code link

Drawing Mountains in OpenGL Using Bitmap Loaders

2025-07-26T03:09:00.003+05:30

Using the OpenGL Glut library, we have created numerous straightforward and intricate programs, but none of them have used texturing or image loading. We tried to find how to load image in the Opengl? The stackoverflow question pertaining to "Loading images in openGL" yielded the best response.
Images Loading in OpenGL Graphics Programming
We can claim that working with OpenGL graphics programmiong, the image loading is seems to be difficult task. External libraries such as stb_image.h, DevIL (Developer's Image Library), FreeImage, and SOIL (Simple OpenGL Image Library) are used to read and decode images into raw pixel data; OpenGL does not import image files directly. This data is then sent to the GPU as a texture using OpenGL methods such as glGenTextures, glBindTexture, and glTexImage2D for rendering.
In addition to images/photos/pictures, textures can be used to contain a sizable collection of arbitrary data that can be sent to the shaders for rendering the object.
Drawing Mountains in OpenGL
In this Computer graphics Open project we are going to generate the mountains using the image texture with use of bitmap loaders.

1. Grass Like Texture to Mountains
We are randomly generating the mountains using a normalized pseudo-random number generator and fractal techniques. The windows are displayed differently each time you resize them or start the project program application. This application relies on GLUT and uses a bitmap for the grass texture. Therefore, they were loaded into the program for use using BitmapLoader.h.
2. Random Number for (Gaussian) distribution
Let first define the randomNormal utility function, which uses the central limit theorem approximation (sum of uniform random variables) to produce a random number with a normal (Gaussian) distribution.

double randomNormal (double mu, double sigma) { double sum = 0; for(int i = 0; i < 12; i++) sum = sum + (double)rand()/RAND_MAX; sum -= 6; return sigma*sum + mu; }
3. Texture Creation and Circle Drawing Functions
Using raw bitmap data, createTexture1 loads a texture into OpenGL and sets its filtering mode to nearest neighbor (pixelated look) and wrapping mode to clamp.

Draw_circle uses a polygon of 36 vertices (one every 10 degrees) to approximate a 2D filled circle. This might stand in for the sun or another round object in the picture.

See Also - How to draw circle in OpenGL

4. Fractal Mountain Generation Function
By periodically splitting a quadrilateral and applying a random height displacement, this recursive program creates fractal landscape.
Lighting effects are used to draw the quad once it is sufficiently small (perim <= tolerance). Using the Lambertian model, the lighting simulates diffuse light by shading the polygon according to its normal and light positions.
In order to produce four smaller quads recursively and add height perturbations for realistic terrain detail, it computes a displaced midpoint if it is not small enough.
5. Initialization of OpenGL and Textures
Uses the external method LoadBitmapFile to load the grass bitmap texture from the file. The program exits and prints an error if loading is unsuccessful. Specifies the scene's clipping volume and sets up the OpenGL projection matrix with an orthographic projection (no perspective). transforms the clean background into a dark gray.

Running the Program to get Desire Result
Before compiling the program place the grass image in the source folder, let the program load and run pefectly. If the grass image not present then comiplation will be error free but non loading of image lead to failure of outcome.

Downloads
Source code will be provie for both main program and header file including the bitmap image on request by you to our email id openglprojects@gmail.com

Opengl Computer Graphics Projects on Solar Energy Solar Power

2025-06-18T02:30:00.004+05:30


We are going to get started Opengl Computer Graphics Projects on Solar Power/Solar Energy.

Abstract
The Main aim of this Mini OpenGL Project is to illustrate/demonstrate the working principle of Solar power/Solar Energy using the concepts and usage of pre-built functions in OpenGL.

In this we are going to demo Solar power using OpenGL. During day electricity is generated through solar panels which are set in fields called as solar farms and is transmitted to near by homes and excess is stored in a power station. During night the power station supplies the stored power to homes. We have used input devices like mouse and key board to interact with in the OpenGL C/C++ program.

Solar Power

Solar power is the power or say energy generated by conversion of sunlight into electricity using solar panels. For Generating energy or power these panels (Solar Panels), uses the photovoltaic cells in them which, convert light into direct current (DC). The DC, afterwards converted to alternating current (AC) for further use in electricity supply or to grid connection, or for storage in batteries. This is a renewable, green, clean energy source, with many advantages , helps in minimizing greenhouse gas emissions during operation and save plane from Global warming.

1. The Basics
We are going to code this OpenGL C/C++ program using MS Visual Studio, you are free to use other IDE like Code Block, Dev C++ etc.

First we are going to develop front page where user will input their interaction to start the program. A help screen will also create for getting the information or usage. User will have choice and program will accordingly.

We will implement various primitive functions for creating the square, rectangle and circle shape for create the diagram require for the demo of this Opengl Computer Graphics Projects on Solar Energy.

2. Implementation

2. 1 Various functions used in this program.
glutInit() : interaction between the windowing system and OPENGL is
initiated
glutInitDisplayMode() : used when double buffering is required and depth
information is required
glutCreateWindow() : this opens the OPENGL window and displays the title
at top of the window
glutInitWindowSize() : specifies the size of the window
glutInitWindowPosition() : specifies the position of the window in screen
co-ordinates
glutKeyboardFunc() : handles normal ascii symbols
glutSpecialFunc() : handles special keyboard keys
glutReshapeFunc() : sets up the callback function for reshaping the window
glutIdleFunc() : this handles the processing of the background
glutDisplayFunc() : this handles redrawing of the window
glutMainLoop() : this starts the main loop, it never returns
glViewport() : used to set up the viewport
glVertex3fv() : used to set up the points or vertices in three dimensions
glColor3fv() : used to render color to faces
glFlush() : used to flush the pipeline
glutPostRedisplay() : used to trigger an automatic redrawal of the object
glMatrixMode() : used to set up the required mode of the matrix
glLoadIdentity() : used to load or initialize to the identity matrix
glTranslatef() : used to translate or move the rotation centre from one
point to another in three dimensions
glRotatef() : used to rotate an object through a specified rotation angle

Also See -

Electromagnetic induction demo with opengl graphic program

Mini Solar System Computer Graphics Programs

3D Solar System OpenGL graphics program

Wind Mill C++ Projects Download

3. User Interaction
This program Opengl Computer Graphics Projects on Solar Energy Solar Power includes following interaction through keyboard.

S-> Toggle Day or night
H-> Get Help Menu
Q-> Quit

4. Source Code

The complete Source code of this Opengl Computer Graphics project can be found in the below. Please Let Us know about your opinion, feedback, question, doubt or any other queries in the comments section below.

void draw(){
if(day){
glClearColor(0.9,0.9,0.9,0.0);
}else{
glClearColor(0.3,0.3,0.3,0.0);
}

glPushMatrix();
glRotatef(angle,1,0,0);
glTranslatef(-10,20,-155);
glScaled(1,1,0.6);
if(day){
glColor3f(1,1,0);
}else{
glColor3f(1,1,1);
}
glutSolidSphere(5,100,100);
glPopMatrix();
glPushMatrix();
glTranslatef(0,-10,5);
glScaled(500,10,1000);
glColor3f(0.8,0.7,0.7);
glutSolidCube(1);
glPopMatrix();

drawHouse(-3,0,-55);
drawHouse(-4,0,-35);
drawHouse(-5,0,-15);
drawHouse(-10,0,-15);
//Solar Panels
for(int i=-1;i<3;i++)
{
for(int j=5;j>-2;j--)
drawSolarPanel(i*2,1,j);
}
//draw power station.
stroke_output(0.8,1.8,"Power Station");
// transformer

glPushMatrix();
glTranslatef(15,5,-100);
//glScaled(0,2,0.2);
glColor3f(1,0.3,0.3);
glutSolidCube(15);
glPopMatrix();
//Transformer Power levels
// y axis from 5 to 18 and show growth in one second delay
if(day){
if(grow<=15000){
grow++;
angle+=0.002;
}
}
else{
if(grow>=0){
grow--;
angle-=0.002;
}
}
if(grow>1000){
glPushMatrix();
glTranslatef(14.8,-2,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>2000){
glPushMatrix();
glTranslatef(14.8,-1,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>3000){
glPushMatrix();
glTranslatef(14.8,0,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>4000){
glPushMatrix();
glTranslatef(14.8,1,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>5000){
glPushMatrix();
glTranslatef(14.8,2,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>6000){
glPushMatrix();
glTranslatef(14.8,3,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();

}
if(grow>7000){
glPushMatrix();
glTranslatef(14.8,4,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>8000){
glPushMatrix();
glTranslatef(14.8,5,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();

}
if(grow>9000){
glPushMatrix();
glTranslatef(14.8,6,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>10000){
glPushMatrix();
glTranslatef(14.8,7,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();

}
if(grow>11000){
glPushMatrix();
glTranslatef(14.8,8,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>12000){
glPushMatrix();
glTranslatef(14.8,9,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();

}
if(grow>13000){
glPushMatrix();
glTranslatef(14.8,10,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();
}
if(grow>14000){
glPushMatrix();
glTranslatef(14.8,11,-99.8);
glScaled(1,0.05,1);
glColor3f(1,1,0);
glutSolidCube(15);
glPopMatrix();

}
if(grow>15000){
}
}

void doDisplay()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,-13.0f);
// Write your Own Code Here
if(help1){
help();
}
else
{
draw();
}
GLfloat mat_ambient[]={0.0f,1.0f,2.0f,1.0f};
GLfloat mat_diffuse[]={0.0f,1.5f,.5f,1.0f};
GLfloat mat_specular[]={5.0f,1.0f,1.0f,1.0f};
GLfloat mat_shininess[]={100.0f};
glMaterialfv(GL_FRONT,GL_AMBIENT,mat_ambient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
/*GLfloat lightIntensity[]={3.7f,0.7f,0.7f,1.0f}; Orange
GLfloat light_position[]={2.0f,5.0f,3.0f,1.0f};*/
/*light source properties*/
//if(day){
GLfloat lightIntensity[]={1.7f,1.7f,1.7f,1.0f};
GLfloat light_position[]={2.0f,0.0f,0.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position);
GLfloat light_position2[]={0.0f,0.0f,8.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position2);
GLfloat light_position3[]={0.0f,5.0f,15.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position3);
glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity);
/*}else{
GLfloat lightIntensity[]={0.7f,0.7f,0.7f,0.5f};
GLfloat light_position[]={2.0f,0.0f,0.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position);
GLfloat light_position2[]={0.0f,0.0f,8.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position2);
GLfloat light_position3[]={0.0f,2.0f,2.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position3);
glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity);
}*/
glFlush();
glutSwapBuffers();
}
void mykey(unsigned char key,int x,int y)
{
if(key=='q'||key=='Q')
{
exit(0);
}
if(key=='h'||key=='H')
{
help1=!help1;
glutPostRedisplay();
}
if(key=='s' || key=='S'){
if(day){
day=false;
}else{
day=true;
}
glutPostRedisplay();
glutIdleFunc(doDisplay);
}
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(0,0);
glutCreateWindow("Solar power");
glutDisplayFunc(doDisplay);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glutKeyboardFunc(mykey);
doInit();
glutMainLoop();
return 0;
}

We have so many good programs in OpenGL.

Create OpenGL CG Projects on Networking Data Communication

2025-04-27T03:53:00.013+05:30

We have developed Selective Repeat ARQ a networking based Create OpenGL CG Projects with C/C++. In this post we are going to create new networking based project. As well aware of Internet which help us communicate through various means including mail, chat and social media. We are going to create OpenGL Project on Networking Data Communication. Let's get started with some basics information.

Abstract -

Our Aim is to Create, design and the illustrate the concepts and usage of Data Communication over Internet Using OpenGL C/C++. The Communication between two devices begins with a message/information of which one send the message and other receive it. The first device is called source, or sender while the second device i is the destination/receiver, of the message. The destination receives the message and interprets it. Another element involved in the process is called channel, which consists of the media that provides the pathway over which the message can travel from source to destination.

This program is implemented using various OpenGL functions which are shown below

Various functions used in this program.
glutInit() : interaction between the windowing system and OPENGL is initiated
glutInitDisplayMode() : used when double buffering is required and depth information is required
glutCreateWindow() : this opens the OPENGL window and displays the title at top of the window
glutInitWindowSize() : specifies the size of the window
glutInitWindowPosition() : specifies the position of the window in screen co-ordinates
glutKeyboardFunc() : handles normal ASCII symbols
glutSpecialFunc() : handles special keyboard keys
glutReshapeFunc() : sets up the callback function for reshaping the window
glutIdleFunc() : this handles the processing of the background
glutDisplayFunc() : this handles redrawing of the window
glutMainLoop() : this starts the main loop, it never returns
glViewport() : used to set up the viewport
glVertex3fv() : used to set up the points or vertices in three dimensions
glColor3fv() : used to render color to faces
glFlush() : used to flush the pipeline
glutPostRedisplay() : used to trigger an automatic redrawal of the object
glMatrixMode() : used to set up the required mode of the matrix
glLoadIdentity() : used to load or initialize to the identity matrix
glTranslatef() : used to translate or move the rotation centre from one point to another in three dimensions
glRotatef() : used to rotate an object through a specified rotation angle
Interactions
Interaction with program We can have an interaction with this project using popular input device like mouse and key board are used to interact with this program. Some keys of key board have specific function, we mentioned them below,
‘s/S’ - Start
‘n/N’ – Network
‘a/A’ – About Project
With these above mentioned keys, we can interact with the program. Also we can interact with this program by using mouse (input device), By click on right and left button On right click of mouse menu will occur. Select the option by left click of mouse.

#include #include #include #include #include #include static double x=0.0,x1=-3.0,x2=3.0,y1=0.0,y2=0; static double x8=-4.0,x9=4.0,y8=1.0,y9=1; static double move=-60; static bool pca2pcb=false,pca2rt=false,rt2pca=false, pcb2pca=false, local=false, dubai=false; void P(); void d(); void *font; void *currentfont; void setFont(void *font) { currentfont=font; } void drawstring(float x,float y,float z,char *string) { char *c; glRasterPos3f(x,y,z); for(c=string;*c!='\0';c++) { glColor3f(0.0,1.0,1.0); glutBitmapCharacter(currentfont,*c); } } void stroke_output(GLfloat x, GLfloat y, char *format,...) { va_list args; char buffer[200], *p; va_start(args, format); vsprintf(buffer, format, args); va_end(args); glPushMatrix(); DATA COMMUNICATION over INTERNET 11 Dept. of Computer Science & Engineering. glTranslatef(-2.5, y, 0); glScaled(0.003, 0.005, 0.005); for (p = buffer; *p; p++) glutStrokeCharacter(GLUT_STROKE_ROMAN, *p); glPopMatrix(); } //Windows void window(float x4, float y4) { glLoadIdentity(); glColor3f(1.0,1.5,0.5); glTranslatef(0.0f,0.0f,-11.0f); for(float j=-2;j<1 .5="" 12="" change="" color="" communication="" computer="" computers="" condition="" data="" dept.="" engineering.="" f="" float="" for="" glcolor3f="" glloadidentity="" glpopmatrix="" glpushmatrix="" glrotatef="" glscaled="" gltranslatef="" glutsolidcube="" glutsolidtorus="" i="" if="" indows="" internet="" j="" of="" ondition="" outer="" over="" pc="" pca="" pcb2pca="" pcb="" router="" science="" to="" void="" window1="" x5="" x6="" x7="=5)" x9="" y5="" y6="" y7="" z7="">=-5 && x9<=-4 && x7==-5) glColor3f(1,0,0); glScaled(.7,.7,0); glRotatef(95,1.0f,0.0f,0.0f); glTranslatef(x7,y7,z7); DATA COMMUNICATION over INTERNET 13 Dept. of Computer Science & Engineering. glutSolidCube(.85); glPopMatrix(); glPopMatrix(); } //PC void cpu(float x7, float y7, float z7) { glLoadIdentity(); glColor3f(0.5,0.5,.5); glTranslatef(0.0f,0.0f,-13.0f); glPushMatrix(); glPushMatrix(); glScaled(1,.3,0); glRotatef(95,1.0f,0.0f,0.0f); glTranslatef(x7,y7,z7); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glColor3f(1,1,1); glScaled(1,.3,0); glRotatef(95,1.0f,0.0f,0.0f); glTranslatef(x7,y7,z7); glutSolidCube(.4); glPopMatrix(); glPopMatrix(); } //Draw LAN/WAN void lan(double x8,double y8) { glClearColor(0.6,0.5,.5,0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f,0.0f,-13.0f); router(0,-1); //Data Media (connected to Router) glPushMatrix(); DATA COMMUNICATION over INTERNET 14 Dept. of Computer Science & Engineering. glTranslatef(0.0,1.0,-2.0); glScaled(0.1,5.0,0.1); glColor3f(1,1,1); glutWireCube(1.5); glPopMatrix(); glPushMatrix(); glTranslatef(0.0,0.0,-2.0); glScaled(5.1,0.1,0.1); glColor3f(1,1,1); glutWireCube(1.5); glPopMatrix(); glPushMatrix(); glTranslatef(0.0,0.0,-2.0); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(1,3.5,-1.0,"ROUTER"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(-4.6,.5,-1.0,"PC-A"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(-.5,.5,-1.0,"SWITCH"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(4,.5,-1.0,"PC-B"); glPopMatrix(); //Data Transfer if(pca2pcb){ // data glPushMatrix(); glTranslatef(x8,y8,-2.0); glScaled(0.1,0.1,0.1); glColor3f(x8,0,1); glutSolidCube(1); glPopMatrix(); if(x8>=4){ DATA COMMUNICATION over INTERNET 15 Dept. of Computer Science & Engineering. pcb2pca=true; pca2pcb=false; } } //Ack if(pcb2pca){ glPushMatrix(); glTranslatef(x8,y8,-2.0); glScaled(0.1,0.1,0.1); glColor3f(x8,0,1); glutSolidCube(1); glPopMatrix(); } if(pca2rt) { glPushMatrix(); glTranslatef(x8,y8,-2.0); glScaled(0.1,0.1,0.1); glColor3f(x8,0,1); glutSolidCube(1); glPopMatrix(); } // move the packet out of LAN if(pca2rt && rt2pca==false && y8>=6) { glutIdleFunc(P); } //switch glPushMatrix(); glColor3f(0.5,0.5,1.5); glTranslatef(0.0,0,1.0); glRotatef(15,1.0f,0.0f,0.0f); glScaled(1.2,0.2,1.0); glutSolidCube(1); glPopMatrix(); pc(-5,1,0); cpu(-3.5,7,1.5); DATA COMMUNICATION over INTERNET 16 Dept. of Computer Science & Engineering. pc(5,1,0); cpu(3.5,7,1.5); pc(0,20,2); cpu(0,105,1.5); glFlush(); glutSwapBuffers(); } // Draw Network void network(double ang,double x1,double x2,double y1,double y2) { glClearColor(0.0,0.85,1,0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f,0.0f,-13.0f); glBegin(GL_POLYGON); glColor3f(0.0,1.8,0.0); glVertex2f(-10,0); glVertex2f(10,0); glVertex2f(-10,-10); glVertex2f(-10,10); glEnd(); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(-4.2,2.65,0.0,"LOCAL BUILDING"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(-1.5,3.2,0.0,"EARTH Connected with Fibric Wires"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(2.5,2.65,0.0,"DUBAI BUILDING"); //Earth glPushMatrix(); glColor3f(0.5,0.5,1.5); glScaled(0.8,1,0.8); glTranslatef(0.0,2.2,0.0); glRotatef(ang,0.0f,-1.0f,0.0f); DATA COMMUNICATION over INTERNET 17 Dept. of Computer Science & Engineering. glutSolidSphere(1,20,20); glPopMatrix(); //Building A glLoadIdentity(); glTranslatef(0.0f,0.0f,-12.0f); glPushMatrix(); glTranslatef(-3,-0.5,0.0); glScaled(0.8,2.2,0.8); glutSolidCube(1.8); glPopMatrix(); window(-2.6, 1); //Building B glLoadIdentity(); glTranslatef(0.0f,0.0f,-12.0f); glPushMatrix(); glTranslatef(3,-0.5,0.0); glScaled(0.8,2.2,0.8); glutSolidCube(1.8); glPopMatrix(); window1(3.3, 1); // Line 1 glPushMatrix(); glTranslatef(-3.0,1.0,-2.0); glScaled(0.1,3.0,0.1); glColor3f(1,1,1); glutWireCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(-1.45,2.4,-2.0); glScaled(3.0,0.2,0.1); glColor3f(1,1,1); glutWireCube(1); glPopMatrix(); //Line 2 glPushMatrix(); DATA COMMUNICATION over INTERNET 18 Dept. of Computer Science & Engineering. glTranslatef(3.0,1.0,-2.0); glScaled(0.1,3.0,0.1); glColor3f(1,1,1); glutWireCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(1.45,2.4,-2.0); glScaled(3.0,0.2,0.1); glColor3f(1,1,1); glutWireCube(1); glPopMatrix(); // Transmission of Datapackets glPushMatrix(); // Send Packets if(local){ if(x1==-3 && y1<=2.38) glTranslatef(-3,y1,-2.0); if(y1>=2.38 && x1<=3) glTranslatef(x1,2.38,-2.0); if(x1>=3 && y1>=0) glTranslatef(3,y1,-2.0); if(x1>=3 && y1<=0.0) { dubai=true; local=false; } } // Ack packets if(dubai) { if(x2>=3 && y2<=2.38) glTranslatef(3,y2,-2.0); if(y2>=2.38 && x2>=-3) glTranslatef(x2,2.38,-2.0); if(x2<=-3 && y2>=0.0) glTranslatef(-3,y2,-2.0); if(x2<=-3 && y2<=0.0) DATA COMMUNICATION over INTERNET 19 Dept. of Computer Science & Engineering. { dubai=false; local=true; rt2pca=true; x8=0; y8=6; glutIdleFunc(d); } } glScaled(0.1,0.1,0.1); glColor3f(1,1,1); glutSolidCube(1); glPopMatrix(); glFlush(); glutSwapBuffers(); } void building(double ang) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f,0.0f,-13.0f); glPushMatrix(); glScaled(0.3,1.5,0.3); glRotatef(90,1.0f,0.0f,0.0f); glTranslatef(8.5,0,-0.5); glutSolidTorus(0.2,1.0,40,40); glPopMatrix(); glFlush(); glutSwapBuffers(); } void about() { glClearColor(0.0,0.85,1,0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f,0.0f,-13.0f); setFont(GLUT_BITMAP_TIMES_ROMAN_24); DATA COMMUNICATION over INTERNET 20 Dept. of Computer Science & Engineering. glColor3f(0,0,0); drawstring(-4.2,2,0.0,"About Data Communication"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0,0,0); drawstring(-3.5,1.5,0.0,"1. Data Communications refers to the exchange of data between two devices via some"); glColor3f(0,0,0); drawstring(-3.5,1,0.0," form of transmission medium such as a wire cable."); glColor3f(0,0,0); drawstring(-3.5,.5,0.0,"2. Similarly data and information from one computer system can be transmitted to"); glColor3f(0,0,0); drawstring(-3.5,0.0,0.0," other systems across geographical areas."); glColor3f(0,0,0); drawstring(-3.5,-0.5,0.0,"3. Thus data transmission is the movement of information using some standard methods."); glColor3f(0,0,0); drawstring(-3.5,-1,0.0,"4. The effectiveness of a data communications system depends on"); glColor3f(0,0,0); drawstring(-3.5,-1.5,0.0," four fundamental characteristics: delivery, accuracy, timeliness, and jitter."); glColor3f(0,0,0); drawstring(-3.5,-2,0.0,"5. A network is two or more devices connected through links."); glColor3f(0,0,0); drawstring(-3.5,-2.5,0.0,"6. A link is a communications pathway that transfers data from one device to another."); glColor3f(0,0,0); drawstring(-3.5,-3,0.0,"7. Type of Connection : Point-to-Point & Multipoint."); glFlush(); glutSwapBuffers(); } void s() DATA COMMUNICATION over INTERNET 21 Dept. of Computer Science & Engineering. { lan(-4,1); } void n() { x-=0.07; network(x,0,0,0,0); } void P() { if(local) { if(x1==-3 && y1<=2.38){ y1+=0.01; } if(y1>=2.38 && x1<=3.0) { x1+=0.01; } if(x1>=3 && y1>=0.0){ y1-=0.01; } x+= .07; network(x,x1,x2,y1,y2); } //Dubai to local if(dubai) { if(x2>=3 && y2<=2.38) y2+=0.01; if(y2>=2.38 && x2>=-3) x2-=0.01; if(x2<=-3 && y2>=0.0) y2-=0.01; x+= .07; network(x,x1,x2,y1,y2); } } DATA COMMUNICATION over INTERNET 22 Dept. of Computer Science & Engineering. void d() { if(pca2pcb) { if(x8>=-4 && x8<=4){ x8+=0.01; } lan(x8,0); } if(pcb2pca) { if(x9<=4 && x9>=-4){ x9-=0.01; } lan(x9,0); } // To Dubai if(pca2rt & rt2pca==false) { if(x8>=-4 && y8<=6){ if(x8<=0) {x8+=0.01; } if(x8>=0 && y8<=6) { y8+=0.01; } } lan(x8,y8); } if(rt2pca) { if(x8<=0 && y8<=6){ if(y8>=0) {y8-=0.01; } if(x8>=-4 && y8<=0) DATA COMMUNICATION over INTERNET 23 Dept. of Computer Science & Engineering. { x8-=0.01; } } lan(x8,y8); } } void doInit() { /* Background and foreground color */ glClearColor(0.0,0.0,0.0,0); glViewport(0,0,640,480); /* Select the projection matrix and reset it then setup our view perspective */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(30.0f,(GLfloat)640/(GLfloat)480,0.1f,200.0f); /* Select the modelview matrix, which we alter with rotatef() */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glClearDepth(2.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); } void display() { glClearColor(0.1,0.1,0.5,0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f,0.0f,-13.0f); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(3.0,1.0,1.0); drawstring(-1.5,3.0,0.0,"DEPARTMENT OF COMPUTER SCIENCE"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,1.0,1.0); drawstring(-3.0,2.5,0.0,"Computer Graphics Mini Project on DATA COMMUNICATION IN NETWORK"); DATA COMMUNICATION over INTERNET 24 Dept. of Computer Science & Engineering. setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,1.0,1.0); drawstring(-1,2,0,"Using OPENGL"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,1.0,1.0); drawstring(-0.5,1.5,0,"By"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,1.0,1.0); drawstring(-2,1,0,"BUSHRA JABEEN (USN : 3KB10CS022)"); setFont(GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,1.0,1.0); drawstring(-2,.5,0,"BUSHRA SULTANA (USN : 3KB10CS023)"); stroke_output(-2.0, -1, "s --> Start"); stroke_output(-2.0, -1.75, "A --> About"); stroke_output(-2.0, -3,"q --> Quit"); GLfloat mat_ambient[]={0.0f,1.0f,2.0f,1.0f}; GLfloat mat_diffuse[]={0.0f,1.5f,.5f,1.0f}; GLfloat mat_specular[]={5.0f,1.0f,1.0f,1.0f}; GLfloat mat_shininess[]={50.0f}; glMaterialfv(GL_FRONT,GL_AMBIENT,mat_ambient); glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse); glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular); glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess); GLfloat lightIntensity[]={1.7f,1.7f,1.7f,1.0f}; GLfloat light_position3[]={0.0f,5.0f,5.0f,0.0f}; glLightfv(GL_LIGHT0,GL_POSITION,light_position3); glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity); glEnable(GL_COLOR_MATERIAL); glFlush(); glutSwapBuffers(); } void menu(int id) { switch(id) { case 1:glutIdleFunc(about); DATA COMMUNICATION over INTERNET 25 Dept. of Computer Science & Engineering. break; case 2:glutIdleFunc(s); break; case 3:glutIdleFunc(d); break; case 4:glutIdleFunc(P); break; case 5:glutIdleFunc(n); break; case 6: pca2pcb=true; x8=-4; glutIdleFunc(d); break; case 7: local=true; dubai=false; pca2rt=true; x8=-4.0;x9=4.0;y8=0.0; y9=0; pca2pcb=false; pcb2pca=false; glutIdleFunc(d); break; case 8: pca2rt=false; pca2pcb=false; x8=-4.0;x9=4.0;y8=1.0; y9=0; x=0.0;x1=-3.0;x2=3.0;y1=0.0;y2=2.38; pca2pcb=false;pca2rt=false; pcb2pca=false; glutIdleFunc(s); break; case 9:exit(0); break; } glFlush(); glutSwapBuffers(); glutPostRedisplay(); DATA COMMUNICATION over INTERNET 26 Dept. of Computer Science & Engineering. } void mykey(unsigned char key,int x,int y) { if(key=='s') { glutIdleFunc(s); } if(key=='n') { glutIdleFunc(n); } if(key=='P') { glutIdleFunc(P); } if(key=='A') { glutIdleFunc(about); } if(key=='q'||key=='Q') { exit(0); } } void main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); glutInitWindowSize(1000,480); glutInitWindowPosition(0,0); glutCreateWindow("Data Communication in Network"); glutDisplayFunc(display); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); DATA COMMUNICATION over INTERNET 27 Dept. of Computer Science & Engineering. glEnable(GL_NORMALIZE); glutKeyboardFunc(mykey); glutCreateMenu(menu); glutAddMenuEntry("About Project 'A'",1); glutAddMenuEntry("Local Area Network(LAN) 's'",2); glutAddMenuEntry("Local Area Network(LAN) 'n'",3); glutAddMenuEntry("Wide Area Network(WAN) 'P'",5); glutAddMenuEntry("Transfer data from PC-A to PC-B '1'",6); glutAddMenuEntry("Transfer data from PC-A to Company B -->'2'",7); glutAddMenuEntry("Reset 'r'",8); glutAddMenuEntry("Quit 'q'",9); glutAttachMenu(GLUT_RIGHT_BUTTON); doInit(); glutMainLoop(); }

Download source code

Internal combustion engine - IC engine - OpenGL Computer Graphics Project

2025-02-26T20:56:00.003+05:30

In this post we are going to referring to a project that involves computer graphics related to an internal combustion (IC) engine in particular petrol engine.We are going to focus on the design of engine components, simulations of the engine cycle and will going to show visualizations of how the internal combustion (IC) engine works.
An internal combustion engine (IC Engine) is a type of heat engine that generates power by burning (using oxidizer usually air) fuel (typically gasoline(petrol), diesel, or natural gas etc) inside a combustion chamber. IC engines are used in many vehicles, including cars, motorcycles, trucks, and airplanes. Below is Figure of an Typical  IC engine.

Before going to OpenGL Computer Graphics Project for IC engine let us know some more information about Internal combustion engine.
Here’s a breakdown of how an internal combustion engine works:
Intake: The engine draws in a mixture of fuel and air into the combustion chamber.
Compression: The intake valve closes, and the piston moves upwards, compressing the fuel-air mixture. This increases the pressure and temperature of the mixture.
Power/Combustion: A spark plug ignites the compressed fuel-air mixture, causing a controlled explosion. This explosion pushes the piston down, which creates the mechanical energy to power the engine.
Exhaust: The exhaust valve opens, and the piston moves upwards again to expel the combustion gases out of the cylinder.
The cycle repeats continuously, with pistons moving up and down, creating the power needed to drive a vehicle or perform work. There are two common types of internal combustion engines:
Two-stroke engines: Complete a power cycle with two strokes of the piston (one up and one down).
Four-stroke engines: Complete a power cycle in four strokes (intake, compression, power, and exhaust).

Usages :

Keyboard: 'Space' : stop/start Engine
                   '+' : Speed up Engine
                    '-' :  Speed down Engine

Code :

//Simple Program:
#include<stdlib.h>
#include<GL/glut.h>
#include <math.h>

void *font = GLUT_BITMAP_TIMES_ROMAN_24; char buff[10]; void *fonts[] = { GLUT_BITMAP_9_BY_15, GLUT_BITMAP_TIMES_ROMAN_10, GLUT_BITMAP_TIMES_ROMAN_24 }; int cc=25,cb=65,s=0,speed=30,status=1; float pointer=25; typedef struct { GLfloat x,y;} Pt; Pt q1, q2,q3,q4; GLfloat colors[][3] = {{0.5,0.5,0.5},{0.5,0.5,0.5},{0.8,0.8,0.8},{0.8,0.8,0.8},{0.8,0.8,0.8},{0.4,0.4,0.4}}; void init() { glClearColor(0.0,0,0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,499.0,0.0,499.0); glutPostRedisplay(); } void DrawLine(Pt n1, Pt n2) { glBegin(GL_LINES); for (int i=0;i<3;i++){ glVertex2f(n1.x+i, n1.y+i); glVertex2f(n2.x+i, n2.y+i); } glEnd(); // glFlush(); } void point (float x,float y){ glPointSize(10.0f); glBegin(GL_POINTS); glVertex2f(x,y); glEnd(); //glFlush(); } void rect(Pt n1, Pt n2,Pt n3, Pt n4){ glBegin(GL_QUADS); // Draw The Cube Using quads // glColor3f(0.0f,1.0f,0.0f); // Color Blue glVertex2f(n1.x, n1.y); glVertex2f(n2.x, n2.y); glVertex2f(n3.x, n3.y); glVertex2f(n4.x, n4.y); glEnd(); // End Drawing The Cube //glFlush(); } void Circle(float cx, float cy, float r, int num_segments,int h) { //glColor3f(0.0,0.0,1.0); float xx,yy,n; if(h==1) glBegin(GL_LINE_LOOP);// for not filled circle else glBegin(GL_TRIANGLE_FAN); for (int ii = 0; ii < num_segments; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component glVertex2f(x + cx, y + cy);//output vertex } glEnd(); } void quad(Pt n1, Pt n2,int i){ glBegin(GL_QUADS); // Draw The Cube Using quads // glColor3f(0.0f,1.0f,0.0f); // Color Blue glVertex2f(n1.x-i, n1.y); glVertex2f(n1.x+i, n1.y); glVertex2f(n2.x+i, n2.y); glVertex2f(n2.x-i, n2.y); glEnd(); // End Drawing The Cube //glFlush(); } void quadd(Pt n1, Pt n2){ glBegin(GL_QUADS); // Draw The Cube Using quads //glColor3f(0.0f,1.0f,0.0f); // Color Blue glVertex2f(n1.x, n1.y-5); glVertex2f(n1.x, n1.y+5); glVertex2f(n2.x, n2.y+5); glVertex2f(n2.x, n2.y-5); glEnd(); // End Drawing The Cube //glFlush(); } void rectangle(Pt n1, Pt n2,int i){ glBegin(GL_QUADS); // Draw The Cube Using quads //glColor3f(0.0f,1.0f,0.0f); // Color Blue glVertex2f(n1.x-i, n1.y); glVertex2f(n2.x+i, n1.y); glVertex2f(n2.x+i, n2.y); glVertex2f(n1.x-i, n2.y); glEnd(); // End Drawing The Cube //glFlush(); } void outlet(float x,float y){ glColor3fv(colors[3]); glBegin(GL_TRIANGLE_FAN); if(s==1 ) { if(cc>=75 && cc<100 || cc>=0 && cc<=25) glColor3f(0.9,0.96,0.96); } if(s==0){ if(cc>25 && cc<=50){ float r=(cc-25)*0.006; glColor3f(0.9-(r),0.95-(r),0.95-(r)); }} float cx=x+50,cy=y+225,r=32; for (int ii = 0; ii < 100; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=25 && ii<=50) glVertex2f(x + cx, y + cy);//output vertex } r=10; for (int ii = 100; ii >=0; ii--) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=25 && ii<=50) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(x+100, y+234); glVertex2f(x+100, y+256); glVertex2d(x+41, y+256); glVertex2f(x+41, y+234); glEnd(); } void outletcover(float x,float y){ glColor3fv(colors[1]); //glColor3f(0,0,0); glBegin(GL_TRIANGLE_FAN); float cx=x+50,cy=y+225,r=34; for (int ii = 0; ii < 100; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=25 && ii<=50) glVertex2f(x + cx, y + cy);//output vertex } r=8; for (int ii = 100; ii >=0; ii--) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=25 && ii<=50) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(x+100, y+232); glVertex2f(x+100, y+259); glVertex2d(x+42, y+259); glVertex2f(x+42, y+232); glEnd(); } void Crank(float cx, float cy, float r, int num_segments) { glColor3f(0.0,0.0,1.0); float xx,yy,n; glBegin(GL_LINE_LOOP);// for not filled circle //glBegin(GL_TRIANGLE_FAN); for (int ii = 0; ii < num_segments; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii==cc){ xx=x+ cx; yy=y+ cy; } } glEnd(); if(cc>=0 && cc<25) {n=cy+125+(cc*1.4);} else if(cc>=25 && cc<=75) {n=cy+160-((cc-25)*1.4);} else if(cc>75 && cc<100) {n=cy+90+((cc-75)*1.4);} glColor3f(0.0f,1.0f,0.0f); q1.x=xx; q1.y=yy; /*glColor3f(0.0f,0.0f,1.0f); q2.x=cx; q2.y=cy; quad(q1,q2,5); q2.x=cx; q2.y=cy; quadd(q1,q2);*/ glColor3f(0.4f,0.4f,0.4f); q2.x=cx; q2.y=n; quad(q1,q2,5); q1.x=cx; q1.y=n; q2.x=cx; q2.y=n+40; //glColor3f(0.0f,0.0f,1.0f); glColor3fv(colors[0]); quad(q1,q2,45); glColor3f(0.4f,0.4f,0.4f); glColor3f(0.4f,0.4f,0.4f); q1.x=cx; q1.y=n+18; q2.x=cx; q2.y=n+28; //quad(q1,q2,45); q1.x=cx; q1.y=n+30; q2.x=cx; q2.y=n+39; //quad(q1,q2,45); Circle(xx,yy,10,100,0);//crank connector Circle(cx,n+10,10,100,0);//piston connecting rod } void Crankrod(float cx, float cy, float r, int num_segments) { float xx,yy,n,xxx,yyy,flg=0; glBegin(GL_TRIANGLE_FAN); for (int ii = 0; ii < num_segments; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=cb && ii<=(cb+20)){ glVertex2f(x + cx, y + cy);//output vertex if(flg!=1) {xxx=x+cx; yyy=y+cy;} } if(cb>=80 && ii<=(20-(100-cb))){ glVertex2f(x + cx, y + cy);//output vertex xxx=x+cx; yyy=y+cy; flg=1; } if(ii==cb){ xx=x+ cx; yy=y+ cy; } } glEnd(); q1.x=xx; q1.y=yy; q2.x=xxx; q2.y=yyy; q3.x=cx; q3.y=cy; q4.x=cx; q4.y=cy; rect(q1,q2,q3,q4); //glColor3f(0.0,0.0,0.0); //Circle(xx,yy,3,100,0); }void valve(float x,float y){ float p=0; if(s==0){ if(cc>=25 && cc<=50) p=-(cc-25)*0.6; else if(cc>50 && cc<75) p=-15+(cc-50)*0.6; } //glColor3f(1.0f,0.0f,0.0f); glColor3fv(colors[5]); q1.x=x-30; q1.y=y+225+p; q2.x=x-30; q2.y=y+220+p; quad(q1,q2,10); q1.x=x-30; q1.y=y+225+p; q2.x=x-30; q2.y=y+276+p; quad(q1,q2,2); p=0; if(s==1){ if(cc>=0 && cc<25) p=-15+(cc)*0.6; if(cc>=75 && cc<100) p=-(cc-75)*0.6; } q1.x=x+30; q1.y=y+225+p; q2.x=x+30; q2.y=y+220+p; quad(q1,q2,10); q1.x=x+30; q1.y=y+225+p; q2.x=x+30; q2.y=y+276+p; quad(q1,q2,2); } void cover(float x,float y){// x=900;y=500; //glColor3f(1.0,1.0,0.0); glBegin(GL_TRIANGLE_FAN); glVertex2d(x-120,y+60); glVertex2d(x-55,y+125); glVertex2d(x+55,y+125); glVertex2d(x+120,y+60); glVertex2d(x+120,y-120); glVertex2d(x-120,y-120); glEnd(); glBegin(GL_TRIANGLE_FAN); //glVertex2d(780,560); glVertex2d(x-55,y+125); glVertex2d(x-55,y+225); glVertex2d(x-20,y+250); glVertex2d(x+20,y+250); glVertex2d(x+55,y+225); glVertex2d(x+55,y+125); glEnd(); } void innlet(float x,float y){ glColor3fv(colors[3]); glBegin(GL_TRIANGLE_FAN); if(s==0 ) { if(cc>=27 && cc<75) glColor3f(0.0,0.5,1.0); if(cc>=75 && cc<100){ float r=(cc-75)*0.032; glColor3f(0.0+r,0.5+(r/2.66),1.0-(r/4)); } } float cx=x-50,cy=y+225,r=32; for (int ii = 0; ii < 100; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=0 && ii<=25) glVertex2f(x + cx, y + cy);//output vertex }r=10; for (int ii = 100; ii >=0; ii--) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=0 && ii<=25) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(x-100, y+256); glVertex2f(x-100, y+235); glVertex2d(x-49,y+235); glVertex2f(x-49, y+256); glEnd(); } void innletcover(float x,float y){ glColor3fv(colors[1]); glBegin(GL_TRIANGLE_FAN); float cx=x-50,cy=y+225,r=34; for (int ii = 0; ii < 100; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=0 && ii<=25) glVertex2f(x + cx, y + cy);//output vertex }r=8; for (int ii = 100; ii >=0; ii--) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=0 && ii<=25) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(x-100, y+259); glVertex2f(x-100, y+232); glVertex2d(x-47,y+232); glVertex2f(x-47, y+259); glEnd(); } void spark(float x,float y){ glColor3f(1,1,0.1); glBegin(GL_TRIANGLE_FAN); //glBegin(GL_LINE_LOOP); //glVertex2f(x-5,y+220); glVertex2f(x+3,y+220); glVertex2f(x+16,y+225); glVertex2f(x+10,y+220); glVertex2f(x+17,y+215); glVertex2f(x-3,y+220); glVertex2f(x-16,y+225); glVertex2f(x-11,y+220); glVertex2f(x-17,y+215); glVertex2f(x+3,y+220); glVertex2f(x+5,y+220); glVertex2f(x,y+210); glVertex2f(x-5,y+220); glEnd(); } void plug(float x,float y){ //float x=217,y=301; glColor3f(0.3,0.3,0.3); glBegin(GL_TRIANGLE_FAN); glVertex2f(x-2, y+19); glVertex2f(x+3, y+19); glVertex2f(x+3, y+24); glVertex2f(x-2, y+24); glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(x-7, y+19); glVertex2f(x+8, y+19); glVertex2f(x+8, y+1); glVertex2f(x-7, y+1); glEnd(); glColor3f(0.0,0.0,0.0); glBegin(GL_QUADS); glVertex2f(x-17, y-1); glVertex2f(x+19, y-1); glVertex2f(x+19, y+1); glVertex2f(x-17, y+1); glEnd(); glColor3f(1.8,1.8,1.0); glBegin(GL_TRIANGLE_FAN); glVertex2f(x-9, y-1); glVertex2f(x+10, y-1); glVertex2f(x+10, y-31); glVertex2f(x-9, y-31); glEnd(); glColor3f(0.0,0.0,0.0); glBegin(GL_LINES); for(int i=0;i<5;i++) { glVertex2f(x+10, (y-1)-(5*i)); glVertex2f(x-9, (y-6)-(5*i)); } glEnd(); glColor3f(1.8,1.8,1.0); glPointSize(7.0f); glBegin(GL_POINTS); glVertex2d(x+1,y-31); glEnd(); glBegin(GL_LINES); glVertex2d(x+6,y-32); glVertex2d(x+6,y-41); glEnd(); glBegin(GL_LINES); glVertex2d(x-2,y-41); glVertex2d(x+6,y-41); glEnd(); glColor3f(0.3,0.3,0.3); glBegin(GL_LINES); float cx=x+25,cy=y+24,r=25; for (int ii = 0; ii < 100; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=25 && ii<=50) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); } void fuel(float x,float y){ float j,i=x,k=y+227,l,flag=0; if(s==0){k=y+224; if( cc>25 && cc<=75){ l=y+170-((cc-25)*1.4); flag=1; glColor3f(0.0,0.5,1.0);//fuel color } if( cc>75 && cc<100){ l=y+100+((cc-75)*1.4); flag=1; float rr=(cc-75)*0.02; glColor3f(rr,0.5-(rr/2),1-rr);//fuel color } if( cc>=0 && cc<25){ l=y+135+(cc*1.4); flag=1; float rr=(cc)*0.02; glColor3f(rr+0.5,0.25-(rr/2),0.5-rr);//fuel color } } if(s==1){ k=(y+225); if(cc>=25 && cc<=75){ l=y+170-((cc-25)*1.4); flag=1; float rr=(cc-25)*0.02; if(rr>=0.95) rr=0.95; glColor3f(1-(rr*0.1),0+rr,0+rr); } if( cc>75 && cc<100){ l=y+100+((cc-75)*1.4); flag=1; glColor3f(0.9,0.95,0.95); } if( cc>=0 && cc<=25){ l=y+135+(cc*1.4); flag=1; glColor3f(0.9,0.95,0.95);//gas color } } if(flag==1){ glBegin(GL_LINES); for(j=k;j>l;j--) { glVertex2f(i-43,j); glVertex2f(i+44,j); } glEnd(); } } void board(float x,float y){ //glColor3f(0.0,1.0,1.0); glColor3f(0.95,1,1); glBegin(GL_QUADS); glVertex2f(x-450,y-250); glVertex2f(x+450,y-250); glVertex2f(x+450,y+450); glVertex2f(x-450,y+450); glEnd(); //glColor3f(0.85,1,1); glColor3f(0.2,.8,.5); glBegin(GL_QUADS); glVertex2f(x-400,y-200); glVertex2f(x+400,y-200); glVertex2f(x+400,y+400); glVertex2f(x-400,y+400); glEnd(); } void smallboard(float x,float y){ //glColor3f(0.0,1.0,1.0); glColor3f(0.95,1,1); glBegin(GL_QUADS); glVertex2f(x-200,y-200); glVertex2f(x+200,y-200); glVertex2f(x+200,y+200); glVertex2f(x-200,y+200); glEnd(); //glColor3f(0.85,1,1); glColor3f(0.2,.8,.5); glBegin(GL_QUADS); glVertex2f(x-160,y-160); glVertex2f(x+160,y-160); glVertex2f(x+160,y+160); glVertex2f(x-160,y+160); glEnd(); } /*void board(float x,float y){ glColor3f(0.3,0.3,0.3); //glColor3f(0.95,1,1); glBegin(GL_QUADS); glVertex2f(x-550,y-250); glVertex2f(x+550,y-250); glVertex2f(x+550,y+450); glVertex2f(x-550,y+450); glEnd(); glColor3f(1.0,1.0,1.0); //glColor3f(0.2,.8,.5); glBegin(GL_QUADS); glVertex2f(x-500,y-200); glVertex2f(x+500,y-200); glVertex2f(x+500,y+400); glVertex2f(x-500,y+400); glEnd(); }*/ void text(int x, int y, char *string,int j) { int len, i; glRasterPos2f(x, y); len = (int) strlen(string); for (i = 0; i < len; i++) { glutBitmapCharacter(fonts[j], string[i]); } } void indicator(float cx, float cy, float r, int num_segments,int h) { //glColor3f(0.0,0.0,1.0); float xx,yy,n; glBegin(GL_TRIANGLE_FAN); glVertex2f(cx, cy);//output vertex for (int ii = 0; ii <= num_segments; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii>=h && ii<=(h+25)) glVertex2f(x + cx, y + cy);//output vertex } glEnd(); } void kk(float cx, float cy, float r, int num_segments){ for (int ii = 0; ii <= num_segments; ii++) { float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle float x = r * cosf(theta);//calculate the x component float y = r * sinf(theta);//calculate the y component if(ii==pointer || ii==(pointer-0.5)) glVertex2f(x + cx, y + cy);//output vertex } } void tip(float cx, float cy, float r, int num_segments){ float xx,yy,n; glBegin(GL_TRIANGLE_FAN); glVertex2f(cx-5, cy-5);//output vertex kk(cx,cy,r,num_segments); glVertex2f(cx+5, cy-5);//output vertex glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(cx-5, cy-5);//output vertex kk(cx,cy,r,num_segments); glVertex2f(cx-5, cy+5);//output vertex glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(cx-5, cy+5);//output vertex kk(cx,cy,r,num_segments); glVertex2f(cx+5, cy+5);//output vertex glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex2f(cx+5, cy-5);//output vertex kk(cx,cy,r,num_segments); glVertex2f(cx+5, cy+5);//output vertex glEnd(); } void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //glClear(GL_COLOR_BUFFER_BIT); int x=800,y=500; //Circle(x, y, 100, 100,0); glColor3f(0.0,1.0,1.0); board(x,y); glColor3fv(colors[1]); cover(x,y); glColor3f(0.8,0.8,0.8); innletcover(x,y); innlet(x,y); outletcover(x,y); outlet(x,y); // glColor3f(1.0,1.0,1.0); glColor3fv(colors[4]); Circle(x, y, 110, 100,0); q1.x=x-44; q1.y=y+100; q2.x=x-44; q2.y=y+225; q3.x=x+44; q3.y=y+225; q4.x=x+44; q4.y=y+100; rect(q1,q2,q3,q4); //inner cylinder fuel(x,y); glColor3f(0.0,0.0,1.0); //reectangle(); //point(x,y+325); glColor3fv(colors[0]); //Crankrod(x, y, 65, 100); Circle(x, y, 50, 100,0); glColor3fv(colors[2]); Crank(x, y, 35, 100); glColor3f(0.0,0.0,1.0); valve(x,y); plug(x,y+253); if(s==0 && cc>=22 && cc<=25 ) spark(x+1,y-2); if(s==1 && cc<=28 && cc>=25 ) spark(x+1,y-2); // title glColor3f(0.0,0.0,1.0); text(x-115,y+415,"IC Petrol Engine",2); y+=150; smallboard(x+700,y); glColor3f(0.3,0.3,0.3); Circle(x+700, y, 145, 100,0); glColor3f(0.9,0.95,0.95); indicator(x+700, y, 140, 100,0); //exhaust glColor3f(0.0,0.5,1.0); indicator(x+700, y, 140, 100,25); //suction glColor3f(0.8,0.5,0.5); indicator(x+700, y, 140, 100,50);//compression glColor3f(0.9,1.0,0.5); indicator(x+700, y, 140, 100,75);// working glColor3f(0.3,0.3,0.3); Circle(x+700, y, 15, 100,0); //glColor3f(0.0,0.0,0.0); tip(x+700, y, 100, 100); glColor3f(0.0,0.0,1.0); text(x+600,y+170,"Stroke Indicator",2); //lables glColor3f(0.0,0.5,1.0); point(x+520,y-240); glColor3f(0.5,0.9,1.0); text(x+540,y-245,"Suction Stroke",0); glColor3f(0.8,0.5,0.5); point(x+520,y-260); glColor3f(0.5,0.9,1.0); text(x+540,y-265,"Compression Stroke",0); glColor3f(0.9,1.0,0.5); point(x+520,y-280); glColor3f(0.5,0.9,1.0); text(x+540,y-285,"Working Stroke",0); glColor3f(0.9,0.95,0.95); point(x+520,y-300); glColor3f(0.5,0.9,1.0); text(x+540,y-305,"Exhaust Stroke",0); text(x-510,y-450,"Press 'space' to start/stop Press '+' to speedup engine Press '-' to slowdown engine",0); glFlush(); //quad(); } void start(){ if(status==1) { cb++; cc++; pointer+=0.5; } if(cc==100) { cc=0; } if(pointer==100) { pointer=0; } if(cb==100) cb=0; display(); //Game title if(cc==25){ if(s==0) s=1; else s=0; } Sleep(speed); } void keypress(unsigned char key, int x,int y){ if (key=='+') {speed--; if(speed<=0) speed=0;} if (key=='-') {speed++;if(speed>=500) speed=500;} if(key==' ') {if(status==0) status=1; else status=0; }} void myReshape(int w,int h) { glViewport(0,0,w,h); glMatrixMode(GL_PROJECTION); glOrtho(-2.0,2.0,-2.0*(GLfloat)h/(GLfloat)w,2.0*(GLfloat)h/(GLfloat)w,-10.0,10.0); glMatrixMode(GL_PROJECTION); } int main(int argc,char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize (600, 600); glutCreateWindow("Introduction to Open GL"); glutReshapeFunc(myReshape); glutKeyboardFunc(keypress); glutDisplayFunc(display); glutIdleFunc(start); init(); glutMainLoop();
}
Here are a few common components that could be part of such the OpenGL Computer Graphics Project:
3D Visualization: Creating a detailed 3D model of a petrol engine, showing key parts like the pistons, crankshaft, valves, and camshaft.
Animation of Engine Cycle: Simulating and animating the stages of the engine cycle, like intake, compression, power, and exhaust strokes.
Computational Fluid Dynamics (CFD) Simulation: Visualizing airflow and combustion processes inside the engine, potentially showing how fuel and air mix, ignite, and exhaust gases are expelled.
Performance Simulation: Using computer graphics to illustrate how engine performance (such as horsepower, torque, fuel consumption) changes with different variables (e.g., RPM, throttle position).

OpenGL Solar System Simulator

2025-01-29T16:37:00.004+05:30

In OpenGL projects blog we are going to demonstrate solar system simulator with Verlet. Here we are using OpenGL for displaying coded and compiled in Visual Studio. We have used glm and glew in this project with MS XML Parser.

We are going to see the important concepts used in this project -
Object oriented programming use the Concept of Class hence here we are going to demonstrate the same. First we are using classes which are getting generated in this application and get done by compiler.
#SolarSystem
Others programs -
1. Mini Solar System Computer Graphics Programs
2. solar System Mini-Project in OpenGL
3.3D Solar System OpenGL graphics program

For this Opengl programming project we need to have the supporting liabrary ie glm and glew. We can download the mentioned liablrary and have to installed them LIBs folder of PC. According to the directory/destination of the glu/gl/ other supporting filles we need to adjust our project settings accordingly.

Download the above libraries from the link provided below -

glm : http://glm.g-truc.net/0.9.7/index.html

glew: http://glew.sourceforge.net/

mfc: This will be already included in the Visual Studio package, if not there kindly check Visual Studio installation guide.

Download Source code -  https://github.com/aromanro/SolarSystem

Video -

New Village Scenery Computer Graphics Project in OpenGL Source Code

2024-01-16T01:33:00.004+05:30

Many of the University including VTU have 'The Department of Computer Science and Engineering' which have Lab projects for students to show thier learning skill which got during thier course study.
VTU Computer Graphics and Visualization Laboratory [15CSL68]
Above mentioned link have the lab programs prescribed by VTU under it course id mentioned have computer graphics project in OpenGL. Under this program students use thier learning ability to show of thier excellence, what they learnt in the course. Many students keeping in focus special efforts to impart thier knowledge to give best projects.
We in this article we are going to show one of the best project in Computer Graphics Project in OpenGL with free source code. The name of the Project is New Village Scenery.
Project Description:
In this Computer Graphics Project in OpenGL with free Source Code are going to draw sun, clouds, sky, river, boats, fence, trees, huts. In this projects we demonstrate the moving clouds in the sky and moving boats in the river, Above is achived by using circle, lines traingle and spheres.

Draw Sky

///sky///
glBegin(GL_POLYGON);
glColor3ub(112,160,228);
glVertex2f(38.0,3.0);
glVertex2f(38.0,14.0);
glVertex2f(-12.0,14.0);
glVertex2f(-12.0,3.0);
glEnd();

Draw the Sun

/// Sun
glPushMatrix();
glColor3d(255,0,0);
glTranslatef(1.0, 7.0, 0);
glutSolidSphere(1.0, 750, 300);
glPopMatrix();

See Also

1. Simple City Scenery Opengl Computer Graphics Project
2. Transformers - Free OpenGL Source code
3. Day and Night OpenGL Computer graphics Project

Implementation
We use GL_QUADS with tranlation in opengl to draw most of the scenery in this new village scenery opengl projects program. As name suggested quads means fourt vertices. We use the glvertex in opengl to join the vertices and make the objects. Below is how vertices are used in opengl.

Draw Components

In this project we are going to use the different functions to implement the different object like sun in the program. void DrawAllComponents() functions is used to draw all the mentioned objects required in this program. After we draw all the objects and then we call them in the display function - void display(void)

After above functions are implemented we call the keyboard and mouse functions to implement the user interactions and call all of them in main functions.
User Interaction
In this opengl project below is user interactions
Mouse interactions
Left Mouse button - Increase the Movement of clouds and boats
Right Mouse button - Decrease the Movement of clouds and boats
Key Interactions
s - to stop the boat
r - to run the boat again
Source code and Reports Computer Graphics Project in OpenGL
Here you can download computer graphics projects with source code and reports.
Below is soure code -
#include<windows.h>
#include <iostream>
#include<GL/gl.h>
#include <GL/glut.h>
#include <math.h>
#include<windows.h>

float moveC = 0.0f;
float moveB1 = 0.0f;
float moveB2 = 0.0f;
float speed = 0.02f;

void DrawAllComponents()
{
glClearColor(1.0f,1.0f,1.0f,1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3d(1,0,0);
glLoadIdentity();
gluOrtho2D(-12,38,-19,14);//range
glMatrixMode(GL_MODELVIEW);

///sky///
glBegin(GL_POLYGON);
glColor3ub(112,160,228);
glVertex2f(38.0,3.0);
glVertex2f(38.0,14.0);
glVertex2f(-12.0,14.0);
glVertex2f(-12.0,3.0);
glEnd();

/// Sun
glPushMatrix();
glColor3d(255,0,0);
glTranslatef(1.0, 7.0, 0);
glutSolidSphere(1.0, 750, 300);
glPopMatrix();

///Cloud-01
glPushMatrix();

glTranslatef(moveC,0.0f,0.0f);
glPushMatrix();
glColor3d(255,255,255);
glTranslatef(1.0, 6.0, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(1.0, 7.0, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(2.0, 7.0, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(2.0, 6.0, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(0.0, 6.5, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(3.0, 6.5, 0);
glutSolidSphere(0.7, 250, 250);
glPopMatrix();

glPopMatrix();

///cloud-02

glPushMatrix();

glTranslatef(moveC,0.0f,0.0f);
glPushMatrix();
glColor3d(255,255,255);
glTranslatef(15.0, 9.0, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(15.0, 8.0, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(16.0, 8.0, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(16.0, 9.0, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(14.0, 8.5, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(17.0, 8.5, 0);
glutSolidSphere(0.8, 250, 250);
glPopMatrix();

glPopMatrix();

///cloud-03
glPushMatrix();

glTranslatef(moveC,0.0f,0.0f);

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(22.0, 8.0, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(22.0, 7.0, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(23.0, 8.0, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(23.0, 7.0, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(24.0, 7.5, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPushMatrix();
glColor3d(255,255,255);
glTranslatef(21.0, 7.5, 0);
glutSolidSphere(0.75, 250, 250);
glPopMatrix();

glPopMatrix();

///See portion
glPushMatrix();
glBegin(GL_POLYGON);
glColor3ub(65,105,225);

glVertex2f(40.0,-19.0); /// right-down
glVertex2f(38.0,-11.0); /// right-top
glVertex2f(-12.0,-11.0); /// left-top
glVertex2f(-12.0,-19.0); /// left-down
glEnd();

///Ground portion
glBegin(GL_POLYGON);
glColor3ub(25,128,0);

glVertex2f(90.0f, -12.5f); /// angle
glVertex2f(38.0f,-12.0f); /// right-down
glVertex2f(38.0f,3.0f); /// right-top
glVertex2f(-12.0f,3.0f); /// left-top
glVertex2f(-12.0f,-11.0f); /// left-down
glEnd();

/// House Drawing

///1st House
/// FEG
glColor3ub(162, 116, 36);
glBegin(GL_TRIANGLES);
glVertex2f(-8, -2);
glVertex2f(-6, 0);
glVertex2f(-4, -2);
glEnd();

/// FGIH
glColor3ub(214, 42, 50);
glBegin(GL_QUADS);
glVertex2f(-8.023, -5.184);
glVertex2f(-8, -2);
glVertex2f(-4, -2);
glVertex2f(-3.999, -7.219);
glEnd();

///ROPQ
glColor3ub(19, 105, 51);
glBegin(GL_QUADS);
glVertex2f(-6.73, -5.67);
glVertex2f(-6.76, -3.58);
glVertex2f(-5.19, -3.58);
glVertex2f(-5.19, -6.62);
glEnd();

///EGKJ
glColor3ub(124, 85, 17);
glBegin(GL_QUADS);
glVertex2f(-6, 0);
glVertex2f(4, 0);
glVertex2f(6, -2);
glVertex2f(-4, -2);
glEnd();

///GLMI
glColor3ub(156, 9, 16);
glBegin(GL_QUADS);
glVertex2f(-4, -2);
glVertex2f(5.22, -2);
glVertex2f(5.26, -5.11);
glVertex2f(-3.99, -7.22);
glEnd();

///VSTU
glColor3ub(216, 215, 111);
glBegin(GL_QUADS);
glVertex2f(-0.39, -6.40);
glVertex2f(-0.42, -3.62);
glVertex2f(1.95, -3.58);
glVertex2f(1.97, -5.86);
glEnd();

///SZA1V
glColor3ub(19, 105, 51);
glBegin(GL_QUADS);
glVertex2f(-0.42, -3.62);
glVertex2f(0.38, -4.38);
glVertex2f(0.38, -5.53);
glVertex2f(-0.39, -6.40);
glEnd();

///TB1C1U
glColor3ub(19, 105, 51);
glBegin(GL_QUADS);
glVertex2f(1.95, -3.58);
glVertex2f(1.21, -4.38);
glVertex2f(1.21, -5.46);
glVertex2f(1.97, -5.86);
glEnd();

///2nd House
///S1R1W1
glColor3ub(0,0,0);
glBegin(GL_TRIANGLES);
glVertex2f(8.09,-5.01);
glVertex2f(10.96,-2.02);
glVertex2f(14.10, -5.01);
glEnd();

///U1V1Z1W1
glColor3ub(145, 0, 12);
glBegin(GL_QUADS);
glVertex2f(9.15, -5.01);
glVertex2f(9.14, -9.02);
glVertex2f(12.85, -9.04);
glVertex2f(12.84, -5.01);
glEnd();

///A2B2C2D2
glColor3ub(245, 10, 49);
glBegin(GL_QUADS);
glVertex2f(10.36, -6.79);
glVertex2f(10.35, -8.91);
glVertex2f(11.59, -8.99);
glVertex2f(11.58, -6.79);
glEnd();

///1st Tree

glColor3ub(22, 208, 70);
glBegin(GL_QUADS);
glVertex2f(14.88, -6.00);
glVertex2f(20, 0);
glVertex2f(24.98, -6.16);
glVertex2f(21.05, -4.96);
glVertex2f(19.09, -4.95);
glEnd();

///NWJ1H1
glColor3ub(191, 158, 24);
glBegin(GL_QUADS);
glVertex2f(19.02, -6.06);
glVertex2f(20.96, -6.09);
glVertex2f(21, -10.08);
glVertex2f(19.01, -10.08);
glEnd();

/// 2nd Tree
///L1K1M1
glColor3ub(17, 218, 45);
glBegin(GL_TRIANGLES);
glVertex2f(27.02, -6.16);
glVertex2f(30, 0);
glVertex2f(32.93, -6);
glEnd();

///E1F1P1Q1
glColor3ub(191, 158, 24);
glBegin(GL_QUADS);
glVertex2f(29.09, -6.10);
glVertex2f(31.03, -6.05);
glVertex2f(31.05, -10.03);
glVertex2f(29.06, -9.97);
glEnd();

///Rail Line
///N1B
glColor3ub(155, 29, 29);
glBegin(GL_QUADS);
glVertex2f(-12, 2);
glVertex2f(38, 3);
glVertex2f(37.98, 2.69);
glVertex2f(-11.98, 1.71);
glEnd();

glColor3ub(155, 29, 29);
glBegin(GL_QUADS);
glVertex2f(-12.07, 0.72);
glVertex2f(-12.07, 0.48);
glVertex2f(38.02, 1.52);
glVertex2f(38, 1.70);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(-8, 2.08);
glVertex2f(-7.64, 2.08);
glVertex2f(-7.63, 0.63);
glVertex2f(-8, 0.62);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(0.97, 2.31);
glVertex2f(1.28, 2.27);
glVertex2f(1.34, 0.76);
glVertex2f(0.97, 0.75);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(11.98, 2.48);
glVertex2f(12.48, 2.49);
glVertex2f(12.5, 1);
glVertex2f(11.98, 0.98);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(25.45, 2.75);
glVertex2f(26.09, 2.76);
glVertex2f(26.09, 1.27);
glVertex2f(25.45, 1.26);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(33.99, 2.92);
glVertex2f(34.48, 2.93);
glVertex2f(34.58, 1.45);
glVertex2f(34.03, 1.44);
glEnd();

glColor3ub(0, 0, 0);
glBegin(GL_QUADS);
glVertex2f(18.39, 2.69);
glVertex2f(19.16, 2.62);
glVertex2f(19.18, 1.13);
glVertex2f(18.42, 1.11);
glEnd();

///boat-1 speed left to right
glPushMatrix();
glTranslatef(moveB1, 0.0f, 0.0f);
glBegin(GL_QUADS);
glColor3ub(139,69,19);
glVertex2f(1.0f, -14.0f);
glVertex2f(1.50f, -13.0f);
glVertex2f(-2.0f, -13.0f);
glVertex2f(-3.0f, -14.0f);
glEnd();

glBegin(GL_QUADS);
glColor3ub(0,0,0);
glVertex2f(2.0f, -14.5f);
glVertex2f(2.0f, -14.0f);
glVertex2f(-3.0f, -14.0f);
glVertex2f(-3.0f, -14.5f);
glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(-3.0f, -14.5f);
glVertex2f(-3.0f, -14.0f);
glVertex2f(-4.5f, -13.7f);

glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(2.0f, -14.5f);
glVertex2f(3.5f, -13.7f);
glVertex2f(2.0f, -14.0f);

glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(2.0f, -14.0f);
glVertex2f(1.5f, -13.0f);
glVertex2f(1.0f, -14.0f);

glEnd();

glPopMatrix();

///boat-2 motion right to left
glPushMatrix();
glTranslatef(moveB2, 0.0f, 0.0f);
glBegin(GL_QUADS);
glColor3ub(139,69,19);
glVertex2f(22.0f, -17.5f);
glVertex2f(21.0f, -16.5f);
glVertex2f(17.50f, -16.5f);
glVertex2f(18.0f, -17.5f);
glEnd();

glBegin(GL_QUADS);
glColor3ub(0,0,0);
glVertex2f(22.0f, -18.0f);
glVertex2f(22.0f, -17.5f);
glVertex2f(17.0f, -17.5f);
glVertex2f(17.0f, -18.0f);
glEnd();

glBegin(GL_QUADS);
glColor3ub(255,99,71);
glVertex2f(20.5f, -16.5f);
glVertex2f(21.0f, -14.5f);
glVertex2f(18.5f, -14.5f);
glVertex2f(18.0f, -16.5f);
glEnd();

glBegin(GL_QUADS);
glColor3ub(139,69,19);
glVertex2f(19.8f, -14.5f);
glVertex2f(19.8f, -14.0f);
glVertex2f(19.7f, -14.0f);
glVertex2f(19.7f, -14.5f);
glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(17.0f, -18.0f);
glVertex2f(17.0f, -17.5f);
glVertex2f(15.5f, -17.2f);
glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(22.0f, -17.5f);
glVertex2f(22.0f, -18.0f);
glVertex2f(23.5f, -17.2f);
glEnd();

glBegin(GL_TRIANGLES);
glColor3ub(0,0,0);
glVertex2f(17.0f, -17.5f);
glVertex2f(18.0f, -17.5f);
glVertex2f(17.5f, -16.5f);
glEnd();

glPopMatrix();

//end
glPopMatrix();
glutSwapBuffers();
}

void updateC(int value)
{

if(moveC > +36)
{
moveC = -38;
}
moveC += 0.15;

glutTimerFunc(20, updateC, 0);
glutPostRedisplay();
}

void updateB1(int value)
{

moveB1 += speed;
if(moveB1 > 38)
{
moveB1 = -38;
}

// moveB1 += 0.17;

glutTimerFunc(20, updateB1, 0); //Notify GLUT to call update again in 25 milliseconds
glutPostRedisplay();
}

void updateB2(int value)
{

if(moveB2 < -36)
{
moveB2 = +38;
}
//Notify GLUT that the display has changed

moveB2 -= 0.13;

glutTimerFunc(20, updateB2, 0); //Notify GLUT to call update again in 25 milliseconds
glutPostRedisplay();
}

void handleKeypress(unsigned char key, int x, int y)
{
switch (key)
{
case 's'://stops
speed = 0.0f;
break;
case 'r'://runs
speed = 0.02f;
break;
glutPostRedisplay();
}
}

void handleMouse(int button, int state, int x, int y)
{

if (button == GLUT_LEFT_BUTTON)
{
speed += 0.05f;
}

else if (button == GLUT_RIGHT_BUTTON)
{
speed -= 0.05f;
}
glutPostRedisplay();
}

void display(void)
{
DrawAllComponents();
glFlush ();
}

void init()
{

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize(1300, 700);
glutInitWindowPosition(100,100);
glutCreateWindow(" Village Scenery ");
init();

glutTimerFunc(100, updateC, 1); // cloud speed
glutTimerFunc(100, updateB1, 0); //Boat 1
glutTimerFunc(100, updateB2, 0); //boat 2

glutKeyboardFunc(handleKeypress);
glutMouseFunc(handleMouse);
glutDisplayFunc(display);

glutMainLoop();
return 0;
}

Satellites Launch Mini Projects OpenGL Computer graphics

2023-03-12T02:58:00.001+05:30

ISRO has made our county proud. They have lauched so many sattelites into the sapce for tele communication, sciencetific discovery, defence, remote sensing, meteorolog etc. In this article we are going to code satellite launch mini projects using opengl computer graphcis in c/c++.

We launch satellites into space by putting them on rockets. The rockets carrying satellites launch via a luching station through tons of propellants (fules of rocket). The propellants provide energy to the rocket to get out of Earth gravity 's pull (Speed is called escape velocity). Rocket with even thrust get into space at mutliple stages. The final stage of the rocket is to place the satellite into it orbit.

Aim of the Mini Projects
The aim of this Satellites Launch Mini Projects with OpenGL Computer graphics is to simulate the lauch if satellites using the opengl functions and codes. We are going to create the Earth, rocket, satellites using opengl and simulate the actual lauching of satellites.

Design and Implementation
1. Drawing of Earth -

2. Drawing of Rocket-

3. Drawing of Satellite -

Do You Know?

ISRO have student satellite program. Students who want to working in space technology may develope the payload for satellites with the help of ISRO through thier university.

User Interaction in the program
The Satellites Launch Mini Projects OpenGL Computer graphics program includes interaction through keyboard as mentioned below -

P - Launch the rocket
Q- Quit

Download the source of Mini Projects OpenGL

Create Pendulum in OpenGL Computer Graphics Program

2023-02-18T23:15:00.005+05:30

We have created many simple programs using OpenGL C/C++ in this blog. In this post we are going to create another simple opengl program. We are creating a simple pendulum. You can use these code as base to create a project particlualry based on the use of pendulum.
Introduction
A pendulum can be define as a certain mass of object tied from a pivot that can swings back and forth due to force of gravity. The Pendulum swing at the same distance in both the directions. The angle made by pendulum from the centre on bothe side are equal and called amplitude of pendulum.

Design and Code
This simple pendulum opengl graphics program we are going to code will have two things - circle and lines. We are going to create a simple circle as clock and attache thread to it with a small circle to it. We will swing the circle right and left from the center point of it attachement with thread.

Learn how to draw a circle in opengl

First in this computer graphics program we are going to write a function for coding circles. We are goint to name this functions as drawcircle. The function will have four arguments segments, radius, x, y. As name suggest these are angle (segments), radius of thread, x and y coordinates.

float drawCircle(float segments,float radius,float sx,float sy)
{
glBegin(GL_LINE_LOOP);
for(int i=0;i<segments;i++)
{
float theta=2.0*3.142*float(i)/float(segments); //get the current angle
float x=radius*cos(theta);
float y=radius*sin(theta);
glVertex2f(x+sx,y+sy);
}
glEnd();
}

Now we are going to draw the pendulum with the help of draw functions which looks like -

void draw(float x1,float y1,float angle)
{
float segments=100;
float radius=6.0;

//Drawing Clock main Circle
glLineWidth(4);
glColor3f(1,0,0);
drawCircle(segments,radius,x1,y1);

//Drawing Minute Line
glColor3f(1,1,0);
glLineWidth(2);
glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(x1,(radius/3.0)*2.0);
glEnd();

//Drawing Hour Line
glColor3f(1,0,0);
glLineWidth(2);
glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(radius/3.0,radius/3.0);
glEnd();
//Drawing Pendulum Circle
double radians=angle*3.142/180;
float x2=(radius*3.4)*cos(radians);
float y2=(radius*3.4)*sin(radians);
float radius2=radius/3.0;

glColor3f(0,0,1);
//glLineWidth(2);
drawCircle(segments,radius2,x2,y2);

glBegin(GL_LINES);
glVertex2f(x1,-1*(radius)+0.2);
glVertex2f(x2,y2);
glEnd();
}

In above opengl computer graphics program code we have drawn a simple clock with hour and minute hands.You may skip therse as they are just to make this program look realstic and more sensible. In last few line we were able to draw the pendulum circle and the thread with the help of circle functions above and GL_LINES.

As we have the draw function we applying the below logic to make the right and left movment of pendulum and thread.

if(angle>315)
{
angle=315;
inc=-inc;
}
if(angle<225)
{
angle=225;
inc=-inc;
}

We are going to place all the code in display function and then create the main functions. You can see the output below.
Outpu Pendulum OpenGL Program

Projects Suggestion
1. Simple Old Mechanical Clock
2. Clock tower with long pendulam Clock
3. Different kinds of swings
4. Circus swings with jokers
5. Amusment park with swings
Download
Get the full code of the

Download source code

Atom Simulation - computer graphics projects with source code

2023-02-05T23:53:00.002+05:30

Download the project Atom Simulation - computer graphics projects with source code file. The Atom simulation is OpenGL computer graphics projects uses a single window.
OpenGL (Open Graphics Library) is a cross-platform, industry-standard graphics API used for creating 3D applications and games. It provides a set of commands for drawing 2D and 3D objects, as well as managing the rendering pipeline, lighting, shading, and texturing.
One of the advantages of using OpenGL is that it provides a low-level interface to the graphics hardware, which means that it can be used on a variety of platforms, including Windows, macOS, Linux, and mobile devices. It also allows developers to take advantage of the latest hardware advancements and performance optimizations.
This is the Atom simulation: This window contains all content that is the menu bar and display of the simulation.

This window is used for all events and for this project.
In this window, we display the simulation of the 10 atoms of the periodic table.
And all mouse and keyboard events triggered in window.
All labels and information about the model displayed on this window.

Key	Action
N	Toggle Night Mode
R	Toggle Rain
B	Toggle Bus
C	Toggle Cars
P	Toggle Plane
ESC	Exit Program

Function	Purpose
glBegin()	Start drawing
glEnd()	End drawing
glVertex2f()	Define point
glColor3f()	Set color
glClear()	Clear screen
glFlush()	Show drawing
glRotatef()	Rotate object
glTranslatef()	Move object
glPushMatrix()	Save position
glPopMatrix()	Restore position

Tool	Purpose
OpenGL	Graphics rendering API
C++	Primary programming language
GLFW	Window creation and input handling
GLAD / GLEW	OpenGL function loading
GLM	Mathematics library
stb_image	Texture loading
Assimp	3D model loading
Dear ImGui	User interface for debugging