DEV Community: Ahmed Mujtaba Butt

Mastering Image Segmentation: How Traditional Techniques Still Shine in the Digital Age

Ahmed Mujtaba Butt — Fri, 13 Sep 2024 20:09:10 +0000

Introduction

Image segmentation, one of the most basic procedures in computer vision, allows a system to decompose and analyze various regions within an image. Whether you're dealing with object recognition, medical imaging, or autonomous driving, segmentation is what breaks images down into meaningful parts.

Although deep learning models continue to be increasingly popular in this task, traditional techniques in digital image processing still are powerful and practical. The approaches being reviewed in this post include thresholding, edge detection, region-based, and clustering by implementing a well-recognized dataset for the analysis of cell images, the MIVIA HEp-2 Image Dataset.

MIVIA HEp-2 Image Dataset

The MIVIA HEp-2 Image Dataset is a set of pictures of the cells used to analyze the pattern of antinuclear antibodies (ANA) through HEp-2 cells. It consists of 2D pictures taken through fluorescence microscopy. This makes it very suitable for segmentation tasks, most importantly those concerned with medical image analysis, where cellular region detection is most important.

Now, let's move on to the segmentation techniques used to process these images, comparing their performance based on the F1 scores.

1. Thresholding Segmentation

Thresholding is the process whereby grayscale images get converted into binary images based on pixel intensities. In the MIVIA HEp-2 dataset, this process is useful in cell extraction from the background. It is simple and effective to a relatively large level, especially with Otsu's method, as it self-computes the optimum threshold.

Otsu's Method is an automatic thresholding method, where it tries to find the best threshold value to yield the minimal intra-class variance, thereby separating the two classes: foreground (cells) and background. The method examines the image histogram and computes the perfect threshold, where the sum of the pixel intensity variances in each class is minimized.

# Thresholding Segmentation
def thresholding(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Otsu's thresholding
    _, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)

    return thresh

2. Edge Detection Segmentation

Edge detection pertains to identifying boundaries of objects or regions, such as cell edges in the MIVIA HEp-2 dataset. Of the many available methods for detecting abrupt intensity changes, the Canny Edge Detector is the best and hence most appropriate method to be used for detecting cellular boundaries.

Canny Edge Detector is a multi-stage algorithm that can detect the edges by detecting areas of strong gradients of intensity. The process embodies smoothing with a Gaussian filter, calculation of intensity gradients, application of non-maximum suppression to eliminate spurious responses, and a final double thresholding operation for the retention of only salient edges.

# Edge Detection Segmentation
def edge_detection(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Gaussian blur
    gray = cv.GaussianBlur(gray, (3, 3), 0)

    # Calculate lower and upper thresholds for Canny edge detection
    sigma = 0.33
    v = np.median(gray)
    lower = int(max(0, (1.0 - sigma) * v))
    upper = int(min(255, (1.0 + sigma) * v))

    # Apply Canny edge detection
    edges = cv.Canny(gray, lower, upper)

    # Dilate the edges to fill gaps
    kernel = np.ones((5, 5), np.uint8)
    dilated_edges = cv.dilate(edges, kernel, iterations=2)

    # Clean the edges using morphological opening
    cleaned_edges = cv.morphologyEx(dilated_edges, cv.MORPH_OPEN, kernel, iterations=1)

    # Find connected components and filter out small components
    num_labels, labels, stats, _ = cv.connectedComponentsWithStats(
        cleaned_edges, connectivity=8
    )
    min_size = 500
    filtered_mask = np.zeros_like(cleaned_edges)
    for i in range(1, num_labels):
        if stats[i, cv.CC_STAT_AREA] >= min_size:
            filtered_mask[labels == i] = 255

    # Find contours of the filtered mask
    contours, _ = cv.findContours(
        filtered_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE
    )

    # Create a filled mask using the contours
    filled_mask = np.zeros_like(gray)
    cv.drawContours(filled_mask, contours, -1, (255), thickness=cv.FILLED)

    # Perform morphological closing to fill holes
    final_filled_image = cv.morphologyEx(
        filled_mask, cv.MORPH_CLOSE, kernel, iterations=2
    )

    # Dilate the final filled image to smooth the edges
    final_filled_image = cv.dilate(final_filled_image, kernel, iterations=1)

    return final_filled_image

3. Region-Based Segmentation

Region-based segmentation groups similar pixels together into regions, dependent on certain criteria such as intensity or color. The Watershed segmentation technique can be used to help in segmenting HEp-2 cell images to be able to detect those regions that represent cells; it considers pixel intensities as a topographic surface and outlines distinguishing regions.

Watershed segmentation treats the intensities of pixels as a topographical surface. The algorithm identifies "basins" in which it identifies local minima and then gradually floods these basins to enlarge distinct regions. This technique is quite useful when one wants to separate touching objects, like in the case of cells within microscopic images, but it can be sensitive to noise. The process can be guided by markers and over-segmentation can often be reduced.

# Region-Based Segmentation
def region_based(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Otsu's thresholding
    _, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)

    # Apply morphological opening to remove noise
    kernel = np.ones((3, 3), np.uint8)
    opening = cv.morphologyEx(thresh, cv.MORPH_OPEN, kernel, iterations=2)

    # Dilate the opening to get the background
    sure_bg = cv.dilate(opening, kernel, iterations=3)

    # Calculate the distance transform
    dist_transform = cv.distanceTransform(opening, cv.DIST_L2, 5)

    # Threshold the distance transform to get the foreground
    _, sure_fg = cv.threshold(dist_transform, 0.2 * dist_transform.max(), 255, 0)
    sure_fg = np.uint8(sure_fg)

    # Find the unknown region
    unknown = cv.subtract(sure_bg, sure_fg)

    # Label the markers for watershed algorithm
    _, markers = cv.connectedComponents(sure_fg)
    markers = markers + 1
    markers[unknown == 255] = 0

    # Apply watershed algorithm
    markers = cv.watershed(img, markers)

    # Create a mask for the segmented region
    mask = np.zeros_like(gray, dtype=np.uint8)
    mask[markers == 1] = 255

    return mask

4. Clustering-Based Segmentation

Clustering techniques such as K-Means tend to group the pixels into similar clusters, which works fine when wanting to segment cells in multi-colored or complex environments, as seen in HEp-2 cell images. Fundamentally, this could represent different classes, such as a cellular region versus a background.

K-means is an unsupervised learning algorithm for clustering images based on the pixel similarity of color or intensity. The algorithm randomly selects K centroids, assigns each pixel to the nearest centroid, and updates the centroid iteratively until it converges. It is particularly effective in segmenting an image that has multiple regions of interest that are very different from one another.

# Clustering Segmentation
def clustering(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Reshape the image
    Z = gray.reshape((-1, 3))
    Z = np.float32(Z)

    # Define the criteria for k-means clustering
    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)

    # Set the number of clusters
    K = 2

    # Perform k-means clustering
    _, label, center = cv.kmeans(Z, K, None, criteria, 10, cv.KMEANS_RANDOM_CENTERS)

    # Convert the center values to uint8
    center = np.uint8(center)

    # Reshape the result
    res = center[label.flatten()]
    res = res.reshape((gray.shape))

    # Apply thresholding to the result
    _, res = cv.threshold(res, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)

    return res

Evaluating the Techniques Using F1 Scores

The F1 score is a measure that combines precision and recall together to compare the predicted segmentation image with the ground truth image. It is the harmonic mean of precision and recall, which is useful in cases of high data imbalance, such as in medical imaging datasets.

We calculated the F1 score for each segmentation method by flattening both the ground truth and the segmented image and calculating the weighted F1 score.

def calculate_f1_score(ground_image, segmented_image):
    ground_image = ground_image.flatten()
    segmented_image = segmented_image.flatten()
    return f1_score(ground_image, segmented_image, average="weighted")

We then visualized the F1 scores of different methods using a simple bar chart:

Conclusion

Although many recent approaches for image segmentation are emerging, traditional segmentation techniques such as thresholding, edge detection, region-based methods, and clustering can be very useful when applied to datasets such as the MIVIA HEp-2 image dataset.

Each method has its strength:

Thresholding is good for simple binary segmentation.
Edge Detection is an ideal technique for the detection of boundaries.
Region-based segmentation is very useful in separating connected components from their neighbors.
Clustering methods are well-suited for multi-region segmentation tasks.

By evaluating these methods using F1 scores, we understand the trade-offs each of these models has. These methods may not be as sophisticated as what is developed in the newest models of deep learning, but they are still fast, interpretable, and serviceable in a broad range of applications.

Thanks for reading! I hope this exploration of traditional image segmentation techniques inspires your next project. Feel free to share your thoughts and experiences in the comments below!

Using PCA for Data Reduction and Face Recognition on LFW Dataset

Ahmed Mujtaba Butt — Wed, 11 Oct 2023 13:22:51 +0000

Principal Component Analysis (PCA) is a powerful technique for dimensionality reduction and feature extraction. It can be used to reduce the size of high-dimensional data, such as images, by projecting them onto a lower-dimensional subspace that captures most of the variance in the data. PCA can also be used to perform face recognition, by comparing the projections of different faces on the same subspace.

In this blog post, we will show you how to apply PCA for data reduction and face recognition on the LFW dataset, which contains images of famous people's faces. We will use Python and scikit-learn to implement PCA and SVM for classification. We will also plot some graphs to visualize the results and compare the performance of different levels of data reduction.

The LFW Dataset

The LFW dataset is a collection of more than 13,000 images of faces collected from the web. Each face has been labeled with the name of the person pictured. The dataset has been widely used for face recognition research and benchmarking.

We will use a cropped version of the LFW dataset, which contains 13,233 images of size 64x64 pixels in grey scale. To split the data into train and test sets, see README.txt and the folder titled 'lists'. You can download the dataset from LFWcrop (cropped Labeled Faces in the Wild).

Implementing PCA

To implement PCA, we will use the scikit-learn library, which provides a convenient function called PCA that can fit and transform the data. We will first load the data and flatten each image into a one-dimensional vector of length 4,096 (64x64). Then we will create a PCA object and fit it on the training data. We can specify the number of components we want to keep, or the percentage of variance we want to preserve, by using the n_components parameter.

For example, if we want to keep 97% of the variance in the data, we can write:

from sklearn.decomposition import PCA
pca = PCA(n_components=0.97)
pca.fit(X_train)

This will find the optimal number of components that can explain 97% of the variance in the data. We can check how many components are kept by using the n_components_ attribute:

print(pca.n_components_)

This will print:

This means that we can reduce the dimensionality of each image from 4,096 to 276 without losing much information.

To transform the data into the lower-dimensional subspace, we can use the transform method:

X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)

We can also plot some of the principal components as images, to see what they look like. The principal components are stored as rows in the components_ attribute of the PCA object. We can reshape them back into images and use matplotlib to display them:

import matplotlib.pyplot as plt
plt.figure(figsize=(12, 12))
for i in range(16):
    plt.subplot(4, 4, i+1)
    plt.imshow(pca.components_[i].reshape(64, 64), cmap='gray')
    plt.title(f'Component {i+1}')
plt.show()

This will produce a plot like this:

Classification with SVM

To perform face recognition on the LFW dataset, we will use a Support Vector Machine (SVM) classifier. SVM is a popular machine learning algorithm that can find a hyperplane that separates different classes of data with maximum margin. We will use scikit-learn's SVC function to create an SVM classifier with a linear kernel.

We will first train and test the classifier on the original data (without PCA), to get a baseline accuracy. We will use accuracy as our evaluation metric, which is simply the percentage of correctly classified images.

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
svm = SVC(kernel='linear')
svm.fit(X_train, y_train)
y_pred = svm.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(f'Accuracy on original data: {acc:.4f}')

This will print:

Accuracy on original data: 0.8385

This means that our classifier can correctly recognize about 84% of the faces in the test set.

Next, we will train and test the classifier on the reduced data (with PCA), and see how the accuracy changes. We will use the same SVC function, but with the transformed data as input.

svm_pca = SVC(kernel='linear')
svm_pca.fit(X_train_pca, y_train)
y_pred_pca = svm_pca.predict(X_test_pca)
acc_pca = accuracy_score(y_test, y_pred_pca)
print(f'Accuracy on reduced data (97% variance): {acc_pca:.4f}')

This will print:

Accuracy on reduced data (97% variance): 0.8416

We can see that the accuracy has slightly improved, even though we have reduced the dimensionality of the data by approximately 15 times. This shows that PCA can help remove some noise and redundancy in the data, and make the classifier more efficient and effective.

Comparing Different Levels of Data Reduction

To see how the accuracy changes with different levels of data reduction, we will repeat the same process with different values of n_components, ranging from 0.9 to 0.99. We will store the accuracy and the number of components for each value in two lists, and plot them as graphs.

n_components_list = [0.90, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99]
accuracy_list = []
n_components_kept_list = []
for n_components in n_components_list:
    pca = PCA(n_components=n_components)
    pca.fit(X_train)
    X_train_pca = pca.transform(X_train)
    X_test_pca = pca.transform(X_test)
    svm_pca = SVC(kernel='linear')
    svm_pca.fit(X_train_pca, y_train)
    y_pred_pca = svm_pca.predict(X_test_pca)
    acc_pca = accuracy_score(y_test, y_pred_pca)
    accuracy_list.append(acc_pca)
    n_components_kept_list.append(pca.n_components_)
    print(f'Variance kept: {n_components}, Accuracy: {acc_pca:.4f}, Components kept: {pca.n_components_}')

This will print:

Variance kept: 0.90, Accuracy: 0.7733, Components kept: 85
Variance kept: 0.91, Accuracy: 0.7826, Components kept: 95
Variance kept: 0.92, Accuracy: 0.7795, Components kept: 107
Variance kept: 0.93, Accuracy: 0.7795, Components kept: 121
Variance kept: 0.94, Accuracy: 0.7981, Components kept: 138
Variance kept: 0.95, Accuracy: 0.8230, Components kept: 160
Variance kept: 0.96, Accuracy: 0.8447, Components kept: 188
Variance kept: 0.97, Accuracy: 0.8416, Components kept: 226
Variance kept: 0.98, Accuracy: 0.8199, Components kept: 282
Variance kept: 0.99, Accuracy: 0.8354, Components kept: 385

We can see that the accuracy increases slightly as we keep more variance in the data, but it reaches a plateau after keeping more than 96% of the variance.

To visualize the results better, we can plot two graphs:

Variance kept vs accuracy
Variance kept vs number of components

plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.plot(n_components_list, accuracy_list)
plt.xlabel('Variance Kept')
plt.ylabel('Accuracy')
plt.title('Variance Kept vs Accuracy')
plt.subplot(1,2,2)
plt.plot(n_components_list,n_components_kept_list)
plt.xlabel('Variance Kept')
plt.ylabel('Number of Components')
plt.title('Variance Kept vs Number of Components')
plt.show()

This will produce a plot like this:

We can see that the accuracy curve increases significantly as we keep more variance in the data, but it reaches a plateau after keeping more than 96% of the variance, while the number of components curve increases sharply as we keep more variance in the data.

This suggests that there is a trade-off between data reduction and accuracy when using PCA for face recognition. If we want to reduce the size of the data as much as possible without losing much accuracy, we can choose to keep around 96% of the variance in the data.

Conclusion

In this blog post, we have demonstrated how to use PCA for data reduction and face recognition on the LFW dataset. We have used scikit-learn to implement PCA and SVM for classification and plotted some graphs to compare the results. We have found that PCA can help reduce the size of the data by approximately 15 times without losing much accuracy, and that keeping around 96% of the variance in the data is a good trade-off between data reduction and accuracy. I hope that this blog post has been helpful and informative for you and that you have learned something new about PCA and face recognition. Thank you for reading!

How to Handle Missing Data???

Ahmed Mujtaba Butt — Tue, 03 Oct 2023 17:45:58 +0000

Missing data is a common problem in data analysis and machine learning. It can occur due to various reasons, such as human errors, sensor failures, or incomplete records. Missing data can affect the quality and validity of the analysis and lead to biased or inaccurate results. Therefore, it is important to handle missing data properly before applying any statistical or machine learning techniques.

In this blog post, I will show you how to handle missing data in Python with pandas, a popular library for data manipulation and analysis. I will use a sample dataset from Kaggle that contains information about passengers on the Titanic. The dataset has some missing values in the columns Age, Cabin, and Embarked. I will demonstrate five different methods to handle missing data and compare their advantages and disadvantages.

You can find the complete code for this blog post in this Kaggle notebook: 5 Methods to Handle Missing Data

Deleting the columns with missing data

One of the simplest methods to handle missing data is to delete the columns (or features) that contain missing values. This method can be applied by using the dropna method in pandas:

df.dropna(axis=1, inplace=True)

This method has the advantage of being easy to implement and avoiding any assumptions about the missing data. However, it also has some drawbacks:

It can result in a significant loss of information and reduce the predictive power of the model.
It can introduce bias if the missing data is not completely random and depends on some other variables.
It can reduce the variability and generalizability of the model by eliminating some important features.

Therefore, this method should only be used when the columns with missing data are irrelevant or redundant for the analysis, or when the proportion of missing data is very high (more than 50%).

Deleting the rows with missing data

Another simple method to handle missing data is to delete the rows (or observations) that contain missing values. This method can also be applied by using the dropna method in pandas:

df.dropna(axis=0, inplace=True)

This method has the advantage of preserving all the features and avoiding any assumptions about the missing data. However, it also has some drawbacks:

It can also result in a significant loss of information and reduce the sample size and statistical power of the test.
It can also introduce bias if the missing data is not completely random and depends on some other variables.
It can increase the variance and overfitting of the model by eliminating some important observations.

Therefore, this method should only be used when the rows with missing data are irrelevant or outliers for the analysis, or when the proportion of missing data is very low (less than 5%).

Filling the missing data with a value – Imputation

A more sophisticated method to handle missing data is to fill (or impute) the missing values with some appropriate value. This method can be applied by using the fillna method in pandas:

df.fillna(value=30, inplace=True)

This method has the advantage of retaining all the information and avoiding any loss of data. However, it also has some drawbacks:

It requires making some assumptions about the distribution and mechanism of the missing data.
It can introduce bias and distortion if the imputed value is not representative or realistic for the missing data.
It can reduce the variability and uncertainty of the model by creating artificial values.

Therefore, this method should only be used when there is a reasonable justification for choosing a specific value for imputing the missing data, such as a domain knowledge or a logical rule.

Filling missing data with a measure of central tendency

A common way to choose a value for imputing missing data is to use a measure of central tendency, such as mean, median, or mode. This method can be applied by using the fillna method in pandas along with a function to calculate the measure of central tendency:

df.fillna(value=df.mean(), inplace=True) # mean for numerical columns and symmetric data
df.fillna(value=df.median(), inplace=True) # median for numerical columns and skewed data
df.fillna(value=df.mode(), inplace=True) # mode for categorical columns

This method has the advantage of being simple and robust to outliers. However, it also has some drawbacks:

It assumes that the missing data is randomly distributed and follows a normal or uniform distribution.
It can introduce bias and distortion if the mean, median, or mode is not representative or realistic for the missing data.
It can reduce the variability and uncertainty of the model by creating artificial values that are equal to each other.

Therefore, this method should only be used when there is no strong evidence that the missing data is not random or follows a different distribution than normal or uniform.

Filling using the most probable value

A more advanced way to choose a value for imputing missing data is to use a statistical or machine learning technique to estimate
the most probable value based on other variables. For example, one can use linear regression to predict a numerical variable based on other numerical variables, or logistic regression to predict a categorical variable based on other categorical variables. This method can be applied by using a library such as scikit-learn to fit a model and make predictions:

from sklearn.linear_model import LinearRegression
lr = LinearRegression()                      # create an instance of the linear regression model
traindf = df[df['Age'].isna()==False].copy() # create a copy of the dataframe with non-missing values of Age as the training set
testdf = df[df['Age'].isna()==True].copy()   # create a copy of the dataframe with missing values of Age as the test set
y = traindf['Age']                           # assign the Age column of the training set as the target variable
traindf.drop("Age", axis=1, inplace=True)    # drop the Age column from the training set as it is not a feature variable
testdf.drop("Age", axis=1, inplace=True)     # drop the Age column from the test set as it is not a feature variable
lr.fit(traindf, y)                           # fit the linear regression model on the training set using the feature and target variables
pred = lr.predict(testdf)                    # predict the Age values for the test set using the fitted model
traindf['Age'] = y                           # add the Age column back to the training set with the original values
testdf['Age'] = pred                         # add the Age column back to the test set with the predicted values
df = pd.concat([traindf, testdf])            # concatenate the training and test sets to form a complete dataframe with no missing values in Age

This method has the advantage of being more accurate and realistic than using a constant value. However, it also has some drawbacks:

It requires making some assumptions about the relationship and correlation between the variables.
It can introduce bias and distortion if the model is not well-fitted or validated for the missing data.
It can increase the complexity and computation time of the model by adding more parameters and steps.

Therefore, this method should only be used when there is a strong evidence that the missing data is related to other variables and can be predicted by a reliable model.

Conclusion

In this blog post, I have shown you how to handle missing data in Python with pandas. I have demonstrated five different methods to handle missing data and compared their advantages and disadvantages. There is no single best method that works for all cases, as different methods have different assumptions and implications. The choice of method depends on various factors, such as the type and amount of missing data, the nature of the problem, and the goal of the analysis. Therefore, it is important to understand the characteristics and limitations of each method and apply them with caution and care.

I hope you found this blog post useful and informative. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!

From HTML to Node.js: 12 Mini Web Projects to Boost Your Web Development Skills

Ahmed Mujtaba Butt — Mon, 01 May 2023 19:12:17 +0000

If you are learning website development, you might be looking for some projects to practice your skills and showcase your work. In this blog post, I will share with you 12 mini-web projects that I developed using different technologies and frameworks. These projects cover various aspects of web development, such as front-end, back-end, user interface, user experience, and data management. You can try these projects as inspiration or as a starting point for your own web development journey. All the projects are hosted on GitHub, and you can find the link below.

01 Course Registration Application Form

This project is built with HTML5, and it allows users to fill out a form to register for a course. The form includes various input fields, radio buttons, and drop-down menus. The form also applies some validation rules to telephone numbers and email formats. The form data is submitted to a server using the POST method. This project is an excellent starting point for learning HTML5 fundamentals.

02 Recipe Cards

This project is built with HTML5 and CSS3, and it displays a collection of recipe cards. Each card has an image of the dish, the name of the dish, a description, star ratings, and an info button. The cards also have some hover effects, such as changing the background colour, and use the box shadow property to add shadow effects. This project is a great way to learn CSS3 fundamentals.

03 The Krusty Krab

This project is built with HTML5 and CSS3, and it is a fully responsive single-page website for a fictional restaurant called "The Krusty Krab" that renders well on all devices. The website has an introduction section containing a title, a full-screen background image with a parallax scrolling effect, and a navigation menu. The website also has a menu section containing food cards, a gallery section, and a footer with contact information. The website uses various CSS properties for responsiveness, such as flexbox, grid, and media query. The website also uses different icons from the Font Awesome library. This project is a great way to learn about HTML and CSS layout and design and how to structure and design a responsive webpage.

04 Restaurant Website

This project is built with HTML5 and Bootstrap 5, and it involves creating a website for a restaurant containing a home page and a contact page. The website uses Bootstrap components, such as the navbar, cards, and forms. The website also uses some Bootstrap classes, such as container-fluid, row, col, btn, dropdown, etc. The website is responsive, and it adapts to different screen sizes. The website also uses various icons from the Font Awesome library. This project is an excellent way to learn about Bootstrap and how it can be used to create a responsive website.

05 Image Slider

This project is built with HTML5, CSS3, and JavaScript and is an image slider that displays multiple images. The image slider has buttons to navigate through the images. The image slider uses JavaScript events, such as onload, and JavaScript functions, such as getElementByClassName. This project is a great way to learn about JavaScript and how it can be used to add interactivity to a website.

06 Application Form with Validation

This project is built with HTML5, CSS3, and JavaScript, and it is an application form that validates the user's input. The form has different input fields, such as name, email, and password. The form uses RegEx (Regular Expression) to apply validation rules to name, email, and password. The form shows error messages depending on the validation results. This project is a great way to learn about regular expressions and form validation and how they can be used to create a user-friendly website.

07 To-Do List

This project is built with HTML5, CSS3, and JavaScript and is a to-do list that allows users to add and delete tasks. The to-do list uses various JavaScript functions, such as createElement, appendChild, removeChild, setAttribute, etc. This project is a great way to learn about how JavaScript can be used to add content and functionality to a website.

08 Weather App

This project is built with HTML5, CSS3, JavaScript, and jQuery and is a weather app that shows the current weather conditions for any location. The weather app uses an API from "OpenWeatherMap" to fetch the weather data. The weather app uses geolocation to get the user's location or allows the user to search for any other location. The weather app also shows a 5-day forecast. The weather app also displays additional information, such as humidity, pressure, visibility, wind speed, sunrise, sunset, and weather icons. This project is a great way to learn about APIs and how they can be used to add real-time data to a website.

09 REST API

This project is built with Node.js and Express.js and uses a REST API. The project uses the Axios library to make HTTP requests, such as GET and POST, to a 'JSONPlaceholder' API to retrieve data. The project also uses bodyParser middleware to parse incoming request data in JSON format. This project is a great way to learn about backend development and REST APIs.

10 Facebook Login Form

This project is built with REACT and replicates the Facebook login form. The login form covers various React fundamentals, such as creating React components, passing props to React components, and rendering React elements. This project is a great way to learn about React and how it can be used to create interactive and dynamic user interfaces.

11 To-Do App

This project is built with REACT and is an enhanced version of the previous to-do app. The to-do app allows users to add, edit, delete, and mark tasks as completed. The to-do app covers various React essentials, such as state management, conditional rendering, and list rendering. This project is a great way to learn about React and React Hooks and how they can be used to create more scalable and reusable applications.

12 Quiz App

This project is built with Node.js, Express.js, and EJS, and it is a quiz app that tests users' knowledge of web fundamentals. The quiz app uses Node.js and Express.js to create the server-side logic and routes, and EJS to render dynamic HTML pages. The quiz app fetches questions from a JSON file (you could also use MongoDB to store the quiz questions and answers) to display them on the web page. The quiz app also deals with handling missing user input, keeping track of the score, and showing the results at the end of the quiz. This project is a great way to learn about server-side rendering, using templating engines, and developing a dynamic web application.

These projects are not only fun and challenging, but they will also help you improve your website development skills. These projects are great for both beginners and intermediate web developers. You can find the source code for these projects on my GitHub page. Feel free to fork, clone, or modify them as you wish.
I want to acknowledge that these projects are not entirely my original ideas. I have taken inspiration from various sources online and adapted them to my own style and preferences.
I hope you enjoyed reading this blog. If you did, please give it a like and share it with your friends. Also, feel free to leave a comment and let me know what you think. I would love to hear your feedback and suggestions. Thank you for reading. I hope you enjoyed it and learned something new!

ahmedmbutt / CS-344-Web

This repo contains around 12 mini projects related to different topics of Web Development

CS-344-Web

This repo contains around 12 mini-projects related to different topics of Web Development.
You can also read my blog about these projects at: DEV | Medium

#	Mini-Project	Built with
01	Course Registration Application Form	HTML5
02	Recipe Cards	HTML5, CSS3
03	The Krusty Krab	HTML5, CSS3
04	Restaurant Website	HTML5, Bootstrap
05	Image Slider	HTML5, CSS3, JS
06	Application Form with Validation	HTML5, CSS3, JS
07	Todo List	HTML5, CSS3, JS
08	Weather App	HTML5, CSS3, JS, jQuery
09	REST API	Node.js, Express.js
10	Login Form	REACT
11	Todo App	REACT
12	Quiz App	Node.js, Express.js, EJS

View on GitHub