Original image apply clahe features

From the dataset

Apply LDA feature

CLAHE:

CLAHE stands for Contrast Limited Adaptive Histogram Equalization. It's a technique used in image
processing and computer vision to improve the contrast of an image. Here's a breakdown of what
CLAHE involves:

1. **Histogram Equalization**: This is a technique to enhance the contrast of an image by

redistributing the intensity values. It works by transforming the intensity values of pixels so that the
histogram of the output image is approximately flat.

2. **Adaptive Histogram Equalization (AHE)**: AHE improves upon histogram equalization by

dividing the image into small regions (tiles) and applying histogram equalization independently to
each tile. This approach enhances local contrast but can also amplify noise in relatively
homogeneous regions.

3. **Contrast Limited Adaptive Histogram Equalization (CLAHE)**: To address the noise amplification
issue of AHE, CLAHE introduces a contrast limit. This means that in regions where the contrast
enhancement would lead to noise, the algorithm limits the contrast enhancement to prevent noise
amplification. The contrast limit ensures that the histogram equalization is adaptive but controlled,
producing more visually pleasing results.

CLAHE is particularly useful in medical imaging, satellite imagery, and other applications where
enhancing local contrast without introducing artifacts is crucial. It helps in making images clearer and
more informative for analysis and interpretation.

CLAHE ALGORITHM APPLYING AN IMAGE:

import cv2
import numpy as np
from matplotlib import pyplot as plt
ch_n=[]

img = cv2.imread("img/normal-1.jpg", cv2.COLOR_BGR2YUV)

cv2.imshow("original image", img)

equ = cv2.equalizeHist(img)
plt.hist(equ.flat,bins=600,range=(0, 256))

cv2.imshow("Equalized", equ)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img)
#cl.append(cl1)
cv2.imshow("CLAHE", cl1)
cv2.waitKey(0)
cv2.destroyAllWindows()
ORIGINAL IMAGE

EQUALIZED IMAGE:

CLAHE IMAGE:
ADVANTAGE OF CLAHE:

The main advantages of Contrast Limited Adaptive Histogram Equalization (CLAHE) include:

1. Enhanced Local Contrast: CLAHE improves the contrast of images by adjusting the intensity values
locally, which means it can enhance details that might be lost in shadows or highlights in
conventional methods.

2. Preservation of Local Characteristics: Unlike global histogram equalization, which can lead to over-
enhancement and artifacts, CLAHE operates locally. It adapts to the local characteristics of the image,
preserving details and textures while enhancing contrast.

3. Reduced Amplification of Noise: CLAHE includes a mechanism to limit contrast enhancement in

regions where it would amplify noise. This helps in maintaining a balance between enhancing
contrast and keeping noise levels under control, leading to visually more appealing and clearer
images.

4. Application Flexibility: It can be applied to a wide range of images, including medical images (such
as X-rays and MRI scans), satellite imagery, and various types of digital photographs. This versatility
makes CLAHE a valuable tool in various fields of image processing and computer vision.

5. User-Controlled Parameters: CLAHE allows for parameters like clip limit and tile size to be adjusted
by the user, offering flexibility in tuning the enhancement process according to specific image
characteristics and application requirements.

Overall, CLAHE is effective in improving the quality and interpretability of images by enhancing
contrast while minimizing artifacts, making it a preferred method in many image processing
applications.
MACHINE LEARNING:

Machine learning is a branch of artificial intelligence (AI) focused on developing algorithms and
techniques that allow computers to learn and make decisions based on data. Instead of explicitly
programmed instructions, machine learning algorithms use statistical models to analyze and identify
patterns in data.

The core idea is to enable machines to learn from experience, improve performance over time, and
make predictions or decisions without being explicitly programmed for each task. Machine learning
is used in various applications such as image and speech recognition, medical diagnosis,
recommendation systems, autonomous vehicles, and more.

TYPES OF MACHINE LEARNING:

Machine learning can be broadly categorized into three main types based on the nature of the
learning and the type of data used for training:

1. Supervised Learning: In supervised learning, the algorithm learns from labeled data, where each
example is a pair consisting of an input object (typically a vector) and a desired output value (also
called the supervisory signal). The goal is to learn a mapping from inputs to outputs so that it can
predict the output values for new, unseen data. Examples include classification (predicting
categories) and regression (predicting continuous values).

2. Unsupervised Learning: In unsupervised learning, the algorithm learns patterns from unlabeled
data. The objective is to find hidden structures or patterns in the input data. Unlike supervised
learning, there are no correct output labels. Clustering (grouping similar data points together) and
dimensionality reduction (reducing the number of random variables under consideration) are
common tasks in unsupervised learning.

3. Reinforcement Learning: Reinforcement learning (RL) involves an agent that learns to make
decisions by interacting with an environment. The agent learns to achieve a goal (like maximizing
rewards) through trial and error. It receives feedback in terms of rewards or penalties as it navigates
the problem space, allowing it to learn the best course of action. Applications of reinforcement
learning include game playing (e.g., AlphaGo), robotics, and autonomous driving.

These types of machine learning can also be further categorized into other subtypes and methods,
such as semi-supervised learning, active learning, and more specialized techniques within each
category. The choice of learning type depends on the specific problem and the availability of labeled
data, among other factors.
CLASSIFICATION IN IMAGE PROCESSING:

In image processing, classification refers to the task of categorizing or labeling an entire image based
on its visual content. This process involves analyzing the features of an image and assigning it to one
or more predefined classes or categories. Image classification is a fundamental problem in computer
vision and is used in various applications, including object recognition, scene understanding, medical
diagnosis, satellite imagery analysis, and more.

Steps Involved in Image Classification in Image Processing:

1. Data Acquisition and Preprocessing:

Data Collection: Gather a dataset of labeled images where each image is associated with a class
label (e.g., cat, dog, car).

Preprocessing : Prepare images by resizing them to a uniform size, converting them to a suitable
format (e.g., RGB or grayscale), and normalizing pixel values to a common scale (e.g., 0 to 1).
Preprocessing ensures consistency and facilitates efficient feature extraction.

2. Feature Extraction:

Traditional Methods : Use handcrafted features such as Histogram of Oriented Gradients (HOG),
Local Binary Patterns (LBP), or color histograms. These features capture specific aspects of the
image's texture, shape, or color distribution.

Deep Learning : Employ Convolutional Neural Networks (CNNs), which automatically learn
hierarchical representations of images through convolutional layers. CNNs are highly effective for
feature extraction in image classification tasks due to their ability to capture spatial hierarchies of
features.

3. Model Training and Selection:

Traditional Machine Learning : Train classifiers such as Support Vector Machines (SVM), Random
Forests, or k-Nearest Neighbors (k-NN) on the extracted features. These classifiers learn to
distinguish between different classes based on the feature vectors derived from images.

Deep Learning: Train CNN models end-to-end using labeled images. This involves feeding images
and their corresponding labels into the network, optimizing model parameters (e.g., weights and
biases) through backpropagation, and adjusting hyperparameters (e.g., learning rate, batch size) to
maximize classification accuracy.

4. Evaluation and Performance Metrics:

Metrics: Evaluate the performance of the trained classifier using metrics such as accuracy, precision,
recall, and F1-score on a separate validation or test dataset. These metrics quantify how well the
classifier correctly identifies images belonging to different classes.
 Fine-tuning : Fine-tune the model by adjusting hyperparameters or modifying the network
architecture based on evaluation results to improve classification performance.

5. Deployment and Application:

Deploy the trained model to classify new, unseen images in real-time applications. Ensure that
input images are pre processed in the same manner as during training (e.g., resizing, normalization)
to achieve accurate classification results.

Example Scenario:

Medical Imaging: Classifying medical images (e.g., X-rays, MRI scans) into categories such as healthy
vs. diseased tissues or specific diseases based on visual patterns.

Remote Sensing: Analyzing satellite images to classify land cover types (e.g., forests, urban areas,
water bodies) for environmental monitoring or urban planning.

Object Recognition: Identifying objects in images for applications in autonomous vehicles, robotics,
and security systems.

Key Considerations:

Data Quality: Ensure the quality and diversity of the training dataset to improve the model's
generalization capability.

Computational Resources: Deep learning models, particularly CNNs, require significant

computational resources (e.g., GPUs) for training and inference.

Transfer Learning: Utilize pre-trained models and transfer learning techniques to leverage learned
features and optimize performance, especially when limited labeled data is available.

Image classification in image processing is a versatile and essential technique that continues to
advance with innovations in machine learning and computer vision, enabling a wide range of
applications across various domains.

In supervised machine learning, image classification involves training a model to predict the class
label of an image based on its visual features. Here’s a structured approach to image classification
within the framework of supervised learning:

1. Data Collection and Preparation:

Dataset: Gather a dataset of labeled images where each image is associated with a class label (e.g.,
cat, dog, car).

Preprocessing : Resize images to a uniform size, convert them to a suitable format (e.g., RGB), and
normalize pixel values to a common scale (e.g., 0 to 1). This ensures consistency in input data for the
model.

2. Feature Extraction:
Traditional Methods : Use techniques like Histogram of Oriented Gradients (HOG), Local Binary
Patterns (LBP), or other handcrafted features to represent each image.

3. Training the Model:

Traditional Machine Learning : Train a classifier such as Support Vector Machines (SVM), Random
Forests, or k-Nearest Neighbors (k-NN) on the extracted features.

4. Evaluation and Fine-Tuning:

Metrics: Evaluate model performance using metrics like accuracy, precision, recall, and F1-score on a
separate test set. Adjust model architecture or hyperparameters based on validation results to
optimize performance.

5. Deployment:

- Deploy the trained model to classify new images in real-time applications. Handle input images
similarly to how they were preprocessed during training (e.g., resizing, normalization).

NEEDS OF FEATURE EXTRACTION:

Feature extraction in image classification using supervised machine learning is pivotal for converting
raw pixel data into a condensed and informative representation that facilitates accurate
classification. By transforming high-dimensional pixel values into discriminative features, the process
enhances the model's ability to distinguish between different classes of images while reducing
computational complexity. Effective feature extraction ensures the model can generalize well to
unseen data, handle transformations like scaling and rotation, and aligns with the requirements of
various learning models, whether traditional algorithms relying on hand-crafted features or deep
learning architectures like Convolutional Neural Networks (CNNs) adept at learning hierarchical
features automatically. Ultimately, feature extraction serves to improve both the efficiency and
effectiveness of image classification models by capturing essential visual patterns and structures
essential for accurate classification.
DIFFERENT TYPES OF FEATURE EXTRACTION:

There are several types of feature extraction techniques used in image processing and
machine learning, each tailored to different applications and modeling approaches:

Hand-Crafted Features: These are manually designed features that capture specific
characteristics of images, such as edges, textures, or shapes. Examples include:

o Histogram of Oriented Gradients (HOG): Describes the distribution of

gradient orientations in an image.
o Scale-Invariant Feature Transform (SIFT): Detects and describes local
features in images that are invariant to scale and rotation.
o Local Binary Patterns (LBP): Captures texture information in an image by
comparing each pixel with its neighbours.

Transform-based Methods:

 Principal Component Analysis (PCA): Linear transformation to reduce

dimensionality while retaining most variance in the data.
 Linear Discriminant Analysis (LDA): Supervised dimensionality reduction that
aims to maximize class separability.

These techniques can be used individually or in combination to extract relevant features from
different types of data (images, text, time series, etc.) for various machine learning tasks such as
classification, regression, clustering, and more. The choice of technique depends on the specific
characteristics of the data and the goals of the machine learning application.
PCA:

PCA stands for Principal Component Analysis. It is a technique used in statistical analysis and
machine learning for dimensionality reduction. Here's a breakdown of what PCA involves and its
primary uses:

1. Dimensionality Reduction: PCA transforms a dataset of possibly correlated variables into a set of
linearly uncorrelated variables called principal components. These principal components are ordered
in such a way that the first few retain most of the variation present in the original dataset. By
retaining the principal components that capture the most variance, PCA reduces the dimensionality
of the dataset.

2. Feature Extraction: PCA can also be used for feature extraction. Instead of reducing the
dimensionality of the dataset, PCA can extract a smaller number of features that are linear
combinations of the original features. These new features are chosen to maximize the variance in the
data.

3. Data Visualization: PCA is often used for visualizing high-dimensional data. It projects the data
onto a lower-dimensional subspace (typically 2D or 3D) so that it can be plotted and visualized more
easily. This is particularly useful for understanding the underlying structure or patterns in the data.

4. Noise Reductio : In some cases, PCA can reduce the effects of noise in the data by focusing on the
components that capture the signal and ignoring the components that represent noise.

5. Preprocessing: PCA is also used as a preprocessing step before applying other machine learning
algorithms. By reducing the dimensionality of the dataset, PCA can speed up the learning algorithm
and improve its performance, especially when dealing with high-dimensional data or when there are
multicollinearities among the predictors.

PCA is a powerful technique widely used in various fields such as image processing, bioinformatics,
finance, and more, where dealing with high-dimensional data is common. Its effectiveness lies in its
ability to capture the essence of the data in a reduced number of dimensions while preserving as
much variance as possible.
ALGORITHM OF PCA APPLYING IN AN DATASET:
import cv2
import zipfile
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report,
confusion_matrix

def resize_image(image, size=(100, 100)):

return cv2.resize(image, size)

faces = {}
with zipfile.ZipFile("C:\\Users\\HP\\OneDrive\\Desktop\\kidney.zip") as
face:
for filename in face.namelist():
if not filename.endswith(".jpg"):
continue # not a face picture
with face.open(filename) as image:
# If we extracted files from zip, we can use
cv2.imread(filename) instead
img = cv2.imdecode(np.frombuffer(image.read(), np.uint8),
cv2.IMREAD_GRAYSCALE)
#img = cv2.imdecode(np.frombuffer(image.read(), np.uint8),
cv2.IMREAD_GRAYSCALE)
resized_img = resize_image(img) # Resize image
faces[filename] = resized_img
import matplotlib.pyplot as plt

fig, axes = plt.subplots(4, 4, sharex=True, sharey=True, figsize=(8, 10))

faceimages = list(faces.values())[-16:] # take last 16 images
for i in range(16):
axes[i % 4][i // 4].imshow(faceimages[i], cmap="gray")
plt.show()
faceshape = list(faces.values())[0].shape
print("Face image shape:", faceshape)
print(list(faces.keys())[:5])
classes = set(filename.split("/")[0] for filename in faces.keys())
print("Number of classes:", len(classes))
print("Number of pictures:", len(faces))
facematrix = []
facelabel = []
for key, val in faces.items():
# if key.startswith("s40/"):
# continue # this is our test set
# if key == "s39/10.pgm":
# continue # this is our test set
facematrix.append(val.flatten())
facelabel.append(key.split("/")[0])

# Create facematrix as (n_samples,n_pixels) matrix

facematrix = np.array(facematrix)
# Apply PCA to extract eigenfaces
from sklearn.decomposition import PCA

pca = PCA().fit(facematrix)
n_components = 12446

eigenfaces = pca.components_[:n_components]
X_train, X_test, y_train, y_test = train_test_split(eigenfaces, facelabel,
test_size=0.3, random_state=42)

# Fit a Gaussian Naive Bayes classifier

gnb = GaussianNB()
gnb.fit(X_train, y_train)

# Predict the class labels

y_pred = gnb.predict(X_test)

# Evaluate the classifier

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

print("Classification Report:")
print(classification_report(y_test, y_pred))

# Plot the confusion matrix

conf_matrix = confusion_matrix(y_test, y_pred)
print(conf_matrix)

ADVANTAGE OF PCA:

Principal Component Analysis (PCA) offers several advantages in the field of data analysis and
machine learning:
1. Dimensionality Reduction: PCA allows for the reduction of the number of variables in a dataset
while retaining as much information as possible. This reduces the complexity of the model and can
lead to improved computational efficiency and performance of subsequent algorithms.

2. Collinearity Reduction: PCA transforms correlated variables into a smaller number of uncorrelated
variables (principal components). This can help mitigate issues caused by multicollinearity in
regression and other statistical models, which can lead to unstable estimates of coefficients.

3. Interpretability: In PCA, each principal component is a linear combination of the original variables.
This linear combination can sometimes be interpreted in the context of the original variables,
providing insights into the underlying structure of the data.

4. Noise Filtering: PCA can effectively filter out noise from the data by focusing on the principal
components that capture the most variance. This can lead to better performance of subsequent
algorithms, especially in noisy datasets.

5. Visualization: PCA can be used for data visualization by reducing the dimensionality of the data to
2 or 3 dimensions. This allows high-dimensional data to be visualized in a scatter plot or other
visualizations, making it easier to identify clusters, patterns, or trends in the data.

6. Feature Extraction: PCA can be used for feature extraction, where the most important features
(pri;ncipal components) are retained while discarding less important ones. This can simplify
subsequent modeling tasks and improve model performance.

Overall, PCA is a versatile and powerful technique that finds application in various domains, including
image processing, bioinformatics, finance, and social sciences, where high-dimensional data analysis
and interpretation are critical.

LDA:

LDA stands for Linear Discriminant Analysis (LDA) is a statistical method commonly used for
dimensionality reduction and classification in machine learning and pattern recognition. Here are
some key points about LDA:

1. Classification and Dimensionality Reduction: LDA is primarily used for finding a linear combination
of features that characterizes or separates two or more classes of objects or events. It can be used
for both classification (supervised learning) and dimensionality reduction.

2. Maximizing Class Separability: The goal of LDA is to project a dataset onto a lower-dimensional
space while preserving as much of the class discriminatory information as possible. It does this by
maximizing the between-class scatter and minimizing the within-class scatter.

3. Assumption of Normality: LDA assumes that the data within each class are normally distributed.
However, it can still perform well in practice even if this assumption is not perfectly met.4. Linear
Transformation: LDA seeks a projection of the data that maximizes the ratio of between-class
variance to within-class variance. This projection is typically represented by a linear transformation
matrix.
5. Application in Face Recognition: LDA has been widely applied in tasks such as face recognition,
where the objective is to find a set of discriminant features that can distinguish between different
individuals in the presence of variations such as pose, illumination, and facial expression.

6. Comparison with PCA: Unlike Principal Component Analysis (PCA), which finds the directions
(principal components) of maximum variance in the data, LDA focuses on the separability between
classes. PCA is unsupervised and orthogonal, while LDA is supervised and considers class labels.

7. Computational Complexity: LDA involves computing scatter matrices and their eigen
decomposition, which can be computationally intensive for large datasets. However, efficient
algorithms and implementations are available to handle practical applications.

8. Regularization: In some cases, regularization techniques are applied to LDA to improve its
performance, especially when the number of samples per class is small compared to the number of
features.

9. Extensions and Variants: There are several extensions and variants of LDA, such as Fisher's Linear
Discriminant Analysis (FLDA), Quadratic Discriminant Analysis (QDA), and Regularized Discriminant
Analysis (RDA), each tailored for specific scenarios or to address certain limitations of standard LDA.

In summary, LDA is a powerful tool for feature extraction and classification, particularly in scenarios
where class discrimination is crucial, such as in image processing tasks like object recognition and
face verification.
import cv2
import zipfile
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report,
confusion_matrix

def resize_image(image, size=(100, 100)):

return cv2.resize(image, size)

faces = {}
with zipfile.ZipFile("C:\\Users\\HP\\OneDrive\\Desktop\\kidney.zip") as
face:
for filename in face.namelist():
if not filename.endswith(".jpg"):
continue # not a face picture
with face.open(filename) as image:
img = cv2.imdecode(np.frombuffer(image.read(), np.uint8),
cv2.IMREAD_GRAYSCALE)
resized_img = resize_image(img) # Resize image
faces[filename] = resized_img
faceshape = list(faces.values())[0].shape
print("Face image shape:", faceshape)
print(list(faces.keys())[:5])
classes = set(filename.split("/")[0] for filename in faces.keys())
print("Number of classes:", len(classes))
print("Number of pictures:", len(faces))
facematrix = []
facelabel = []
for key, val in faces.items():
facematrix.append(val.flatten())
facelabel.append(key.split("/")[0])

# Create facematrix as (n_samples, n_pixels) matrix

facematrix = np.array(facNematrix)

# Apply LDA to extract discriminant features

lda = LDA()
X_lda = lda.fit_transform(facematrix, facelabel)

# Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(facematrix, facelabel,
test_size=0.3, random_state=42)

# Fit a Gaussian Naive Bayes classifier

gnb = GaussianNB()
gnb.fit(X_train, y_train)

# Predict the class labels

y_pred = gnb.predict(X_test)

# Evaluate the classifier

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

print("Classification Report:")
print(classification_report(y_test, y_pred))

# Plot the confusion matrix

conf_matrix = confusion_matrix(y_test, y_pred)
print(conf_matrix)

Original image LDA feature extraction

ADVANTAGE OF LDA

Linear Discriminant Analysis (LDA) offers several advantages in the context of supervised learning and
classification tasks:

1. Dimensionality Reduction: LDA effectively reduces the dimensionality of the feature space by
projecting data onto a lower-dimensional subspace while preserving as much class discriminatory
information as possible. This can lead to simpler and more efficient classification models.

2. Feature Extraction: LDA identifies the linear combinations of features that best separate different
classes in the data. By focusing on discriminative features, it improves the interpretability and
robustness of the model.

3. Improves Classification Accuracy: By maximizing the separability between classes, LDA often leads
to better classification performance compared to using the original feature space. It reduces the risk
of overfitting by focusing on the most informative dimensions.

4. Handles Small Sample Sizes: LDA can perform well even with small sample sizes per class, making
it suitable for datasets where the number of samples is limited relative to the number of features. It
achieves this by leveraging information about the distribution of classes.

5. Computationally Efficient: The computational complexity of LDA primarily involves computing

scatter matrices and their eigenvectors. This process is generally less intensive compared to other
nonlinear dimensionality reduction techniques, making LDA feasible for large-scale datasets.

6. Interpretable Results: The transformation performed by LDA results in a set of basis vectors (linear
discriminants) that can be interpreted in terms of the original features. This makes it easier to
understand and explain the factors contributing to classification decisions.

7. Robust to Noise: LDA is relatively robust to noise and outliers in the data, especially when the
underlying assumptions (such as normality within classes) are approximately met. It focuses on the
overall structure of the data rather than individual data points.
8. No Overfitting in Low-Dimensional Spaces: Unlike some nonlinear dimensionality reduction
methods, LDA does not suffer from overfitting when the dimensionality of the reduced space is
chosen appropriately relative to the number of samples.

In summary, Linear Discriminant Analysis is a powerful tool for feature extraction, dimensionality
reduction, and classification in supervised learning scenarios. Its ability to enhance interpretability,
handle small sample sizes, and improve classification accuracy makes it widely used in fields such as
image processing, bioinformatics, and finance.
HOG :

HOG (Histogram of Oriented Gradients) is a feature descriptor widely used in computer vision and
image processing tasks, particularly in object detection and recognition. Here are some key points
about HOG features:

1. Feature Descriptor: HOG is a feature descriptor technique that captures the shape and appearance
of objects in images. It computes the distribution (histogram) of gradient orientations in localized
portions (cells) of an image.

2. Gradient Orientation: HOG focuses on the distribution of gradient orientations in localized regions
of an image. It computes the gradient (edge) magnitude and direction to describe texture and shape
information.

3. Local Normalization: HOG divides the image into small connected regions called cells and
computes histograms of gradient orientations within each cell. Normalization techniques like
contrast normalization or block normalization are often applied to enhance robustness against
illumination changes and improve performance.

4. Histogram Construction: Within each cell, a histogram of gradient orientations (typically with bins
representing angles) is constructed. This histogram provides a compact representation of the local
gradient structure.

5. Block Structure: To capture spatial relationships and improve discriminative power, neighboring
cells are grouped into blocks. The histograms from these blocks are concatenated or normalized to
form the final feature vector for the image region.

6. Scale and Rotation Invariance: HOG features are robust to variations in scale and partially robust to
changes in rotation. This makes them suitable for tasks where objects may appear at different scales
or orientations.

7. Applications: HOG features are widely used in pedestrian detection, object recognition, and image
segmentation tasks. They have been particularly successful in detecting human bodies and faces in
images and videos.

8. Computationally Efficient: While HOG computation involves multiple steps (gradient computation,
histogram calculation, normalization), it is computationally efficient compared to more complex
feature descriptors like SIFT (Scale-Invariant Feature Transform).
ALGORITHM OF HOG FEATURES IN AN IMAGE:
import os
import cv2
import matplotlib.pyplot as plt
from skimage.feature import hog
from skimage import exposure

# Dataset path
dataset_path = "C:\\Users\\HP\\OneDrive\\Desktop\\CT-KIDNEY-DATASET-Normal-
Cyst-Tumor-Stone"

# Function to apply CLAHE and compute HOG features

def compute_hog(image):
# Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply CLAHE for contrast enhancement

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
gray = clahe.apply(gray)

# Compute HOG features

fd, hog_image = hog(gray, orientations=8, pixels_per_cell=(16, 16),
cells_per_block=(1, 1), visualize=True)

return fd, hog_image

# Iterate over each image in the dataset folder

for filename in os.listdir(dataset_path):
if filename.endswith(".jpg") or filename.endswith(".png"):
# Load the image
image_path = os.path.join(dataset_path, filename)
image = cv2.imread(image_path)

if image is None:
print(f"Error: Could not read {image_path}")
continue

# Compute HOG features

fd, hog_image = compute_hog(image)

# Print number of HOG features (if needed)

print(f"Number of HOG features for {filename}: {len(fd)}")

# Plot the original image and HOG image side by side

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6), sharex=True,
sharey=True)

ax1.axis('off')
ax1.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
ax1.set_title('Original Image')

# Rescale histogram for better display

hog_image_rescaled = exposure.rescale_intensity(hog_image,
in_range=(0, 10))

ax2.axis('off')
 ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
ax2.set_title('Histogram of Oriented Gradients (HOG)')

plt.tight_layout()
plt.show()

ORIGINAL IMAGE AND HOG FEAUTRE:

ADVANTAGES OF HOG FEATURES IN AN IMAGE:

Histogram of Oriented Gradients (HOG) features offer several advantages in computer vision and
image processing applications:

1. Robust to Illumination Changes: HOG features are designed to capture local gradient information,
which makes them relatively robust to changes in illumination across an image. This property makes
them suitable for tasks where lighting conditions can vary.

2. Invariant to Geometric and Photometric Transformations: HOG features are partially invariant to
geometric transformations such as translation and rotation. They can also tolerate moderate changes
in viewpoint and scale, making them versatile for object detection tasks.

3. Simple and Efficient Calculation: The computation of HOG features involves straightforward
operations such as gradient computation, histogram construction, and normalization. This simplicity
contributes to their computational efficiency, allowing them to be applied to large datasets and real-
time applications.
4. Discriminative Power: HOG features effectively capture edge and shape information within
localized image regions. The histograms of oriented gradients provide a concise representation of
local structure, which can be highly discriminative for distinguishing objects from background clutter.

5. Complementary to Other Features: HOG features can be combined with other descriptors or
feature extraction techniques to enhance overall performance. For example, they are often used
alongside color histograms or texture descriptors to improve object recognition accuracy.

6. Interpretable Features: HOG descriptors generate histograms that reflect the local distribution of
gradient orientations. This interpretability allows for intuitive understanding of the features extracted
from images, aiding in debugging and model interpretation.

7. Wide Application Scope: HOG features have been successfully applied in various domains,
including pedestrian detection, face detection, object recognition, and gesture recognition. Their
versatility and effectiveness across different types of images and tasks demonstrate their broad
applicability.

8. Parameter Tuning Flexibility: While HOG has default parameters for gradient computation and
histogram binning, it allows flexibility in parameter tuning based on specific application
requirements. This adaptability enables optimization for different datasets and scenarios.

SIFT FEAUTRES:

SIFT (Scale-Invariant Feature Transform) features are widely used in computer vision for various tasks
such as object recognition, image stitching, and 3D reconstruction. Here are the key advantages of
SIFT features:

1. Scale Invariance: SIFT features are inherently scale-invariant, meaning they can detect keypoints
and describe local features regardless of the image scale. This property enables robust matching and
recognition of objects at different distances or scales within an image.
2. Rotation Invariance: SIFT features are also rotationally invariant, meaning they can detect and
describe keypoints even if the object is rotated in the image. This is achieved through the orientation
assignment during feature extraction.

3. Distinctiveness: SIFT descriptors are highly distinctive and robust to changes in illumination, noise,
and minor geometric transformations (such as changes in viewpoint). This distinctiveness ensures
accurate matching and recognition of objects in challenging conditions.

4. Localization: SIFT features accurately localize keypoints in an image, providing precise information
about where the keypoint is located and its scale and orientation. This localization is crucial for tasks
like object tracking and image alignment.

5. Multi-scale Feature Extraction: SIFT detects features at multiple scales within an image pyramid,
capturing details at different levels of granularity. This multi-scale approach enhances the robustness
and versatility of the features.

6. Local Feature Description: Each SIFT keypoint is described by a feature vector (typically 128-
dimensional), which represents the local image patch surrounding the keypoint. This description
encodes gradient magnitude and orientation information in a manner that is invariant to scale and
rotation.

7.Computationally Efficient Matching: SIFT features use efficient algorithms for keypoint detection,
orientation assignment, and descriptor calculation, making them suitable for real-time and large-
scale image processing applications.

8. Wide Application Scope: SIFT features have been successfully applied in various fields including
object recognition, image retrieval, panorama stitching, augmented reality, and 3D reconstruction.
Their versatility and robustness make them a cornerstone in many computer vision tasks.

9. Open Source Implementations: There are widely used implementations of SIFT available in
libraries such as OpenCV and MATLAB, as well as in other open-source computer vision frameworks.
This availability facilitates easy integration and adoption in diverse projects.

10. Foundation for Advanced Techniques: SIFT features have inspired numerous extensions and
improvements in feature extraction techniques, such as SURF (Speeded-Up Robust Features) and
ORB (Oriented FAST and Rotated BRIEF), and serve as a benchmark for evaluating the performance of
newer methods.
Overall, the combination of scale invariance, rotation invariance, distinctiveness, and efficient
computation makes SIFT features a powerful tool for extracting and matching local image features in
a wide range of computer vision applications.

ALGORITHM FOR SIFT FEATURES IN AN IMAGE:

import cv2
import zipfile
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report,
confusion_matrix

def resize_image(image, size=(100, 100)):

return cv2.resize(image, size)

def extract_sift_features(image):
sift = cv2.SIFT_create()
keypoints, descriptors = sift.detectAndCompute(image, None)
if descriptors is None:
return np.zeros(128) # Return a dummy feature vector if no
keypoints found
return descriptors.flatten()

faces = {}
sift_features_list = [] # List to store SIFT features

with zipfile.ZipFile("C:\\Users\\HP\\OneDrive\\Desktop\\kidney.zip") as
face:
for filename in face.namelist():
if not filename.endswith(".jpg"):
continue # not a face picture
with face.open(filename) as image:
img = cv2.imdecode(np.frombuffer(image.read(), np.uint8),
cv2.IMREAD_GRAYSCALE)
resized_img = resize_image(img) # Resize image
sift_features = extract_sift_features(resized_img) # Extract
SIFT features
faces[filename] = resized_img # Store resized image
sift_features_list.append(sift_features) # Store SIFT features

# Ensure all SIFT features are of the same length (128 dimensions)
max_sift_length = max(len(sift) for sift in sift_features_list)
for i in range(len(sift_features_list)):
if len(sift_features_list[i]) < max_sift_length:
sift_features_list[i] = np.concatenate((sift_features_list[i],
np.zeros(max_sift_length - len(sift_features_list[i]))))

faceshape = list(faces.values())[0].shape
print("Face image shape:", faceshape)
print(list(faces.keys())[:5])
classes = set(filename.split("/")[0] for filename in faces.keys())
print("Number of classes:", len(classes))
print("Number of pictures:", len(faces))
# Convert sift_features_list to numpy array
sift_features_matrix = np.array(sift_features_list)

facematrix = np.array([val.flatten() for val in faces.values()])

# Ensure facematrix and sift_features_matrix have the same number of

columns
if facematrix.shape[0] != sift_features_matrix.shape[0]:
raise ValueError("Number of images does not match between image matrix
and SIFT features matrix.")

# Combine facematrix and sift_features_matrix horizontally

facematrix_with_sift = np.hstack((facematrix, sift_features_matrix))

facelabel = [filename.split("/")[0] for filename in faces.keys()]

# Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(facematrix_with_sift,
facelabel, test_size=0.3, random_state=42)

# Fit a Gaussian Naive Bayes classifier

gnb = GaussianNB()
gnb.fit(X_train, y_train)

# Predict the class labels

y_pred = gnb.predict(X_test)

# Evaluate the classifier

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

print("Classification Report:")
print(classification_report(y_test, y_pred))

# Plot the confusion matrix

conf_matrix = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(conf_matrix)
ADVANTAGES OF SIFT FEATURES:

SIFT (Scale-Invariant Feature Transform) features offer several advantages in computer vision and
image processing applications:

1. Scale Invariance: SIFT features are robust to changes in scale, meaning they can detect and
describe keypoint regardless of the image's scale. This makes them effective for tasks where the size
of objects or scenes may vary.

2. Rotation Invariance: SIFT features are also invariant to image rotation. They achieve this by
assigning an orientation to each keypoint based on local image gradients, allowing for reliable
matching even when objects are viewed from different angles.

3. Distinctiveness: SIFT descriptors are highly distinctive, meaning they encode local image
information in a way that minimizes similarity between different keypoint. This distinctiveness
enables accurate matching and recognition of objects in images, even under varying conditions such
as changes in lighting or viewpoint.

4. Localization: SIFT provides accurate localization of keypoint within an image. Each keypoint is
identified with its precise location and scale, which is crucial for tasks like object tracking, image
stitching, and 3D reconstruction.
5.Multi-scale Feature Extraction: SIFT operates on multiple scales of image pyramids, allowing it to
capture details at different levels of granularity. This multi-scale approach enhances the robustness
of feature extraction across different resolutions within an image.

6. Descriptor Stability: SIFT descriptors are stable under noise and partial occlusion. They achieve this
by considering local gradient histograms around keypoint, which helps in maintaining the integrity of
feature descriptions in challenging image conditions.

7. Efficiency: Despite its computational complexity, SIFT features are efficient enough for real-time
applications and large-scale image datasets. Efficient algorithms for keypoint detection, orientation
assignment, and descriptor calculation contribute to its practical usability.

8. Broad Application Scope: SIFT features have been successfully applied in various domains including
object recognition, image retrieval, panorama stitching, augmented reality, and biomedical imaging.
Their versatility and robustness make them a preferred choice in many computer vision tasks.

9. Benchmark Status: SIFT features have set a benchmark in feature extraction techniques and
continue to influence the development of newer methods. They serve as a reference for evaluating
the performance of other feature descriptors and matching algorithms.

10. **Open Source Implementations**: There are open-source implementations of SIFT available in
popular libraries such as OpenCV and MATLAB, which facilitates its adoption and integration into
different projects and frameworks.

Overall, the advantages of SIFT features, including scale and rotation invariance, distinctiveness,
localization accuracy, and multi-scale feature extraction, make them indispensable in the field of
computer vision for robust and reliable feature-based image analysis and recognition.
LBP :

Local Binary Patterns (LBP) features are widely used in texture analysis and image classification tasks
in computer vision. Here are some key points about LBP features:

1. Local Texture Description: LBP is a texture descriptor that characterizes the local structure of an
image by comparing each pixel with its neighboring pixels.

2. Binary Representation: LBP computes a binary code for each pixel neighborhood by thresholding
the pixel values around it with the center pixel value. This binary representation encodes local
texture patterns.

3. Rotation Invariance: LBP features are inherently rotation-invariant, meaning the same texture
pattern will be represented by the same LBP code regardless of the orientation of the pattern within
the neighborhood.

4. Robust to Illumination Changes: LBP features are robust to monotonic grayscale transformations,
such as changes in illumination. This is because they primarily capture local texture variations rather
than absolute pixel intensities.

5. Histogram Representation: After computing LBP codes for all pixels in an image, a histogram of
these codes is constructed to summarize the distribution of local texture patterns. This histogram
serves as the feature vector for the image region.

6. Efficiency: LBP computation is computationally efficient, making it suitable for real-time

applications and large-scale datasets. It involves simple operations such as pixel comparisons and
histogram calculation.

7. Local Nature: LBP focuses on local texture patterns within a predefined neighborhood around each
pixel. This allows it to capture fine-grained details and variations in textures, which are important for
texture classification tasks.

8. Applications: LBP features are widely used in applications such as texture classification, facial
expression recognition, biomedical image analysis, and material inspection. They excel in scenarios
where texture patterns play a crucial role in distinguishing between different classes.

9. Parameterization: LBP can be parameterized by adjusting the neighborhood size and the number
of sampling points, allowing flexibility to adapt to different texture scales and complexities in images.
10. Extensions and Variants: Over time, several extensions and variants of LBP have been proposed
to enhance its performance or address specific challenges, such as uniform patterns LBP, rotation-
invariant LBP, and multi-scale LBP.

Overall, LBP features provide a robust and efficient method for describing local texture patterns in
images, making them a valuable tool in various computer vision and pattern recognition applications.

Original image LBP feature Extracted

Result analysis
The results of the implemented six models using different tests are evaluated by calculating the
accuracy, recall, F1 score (F1), accuracy (Acc), positive predictive value (PPV), and ROC curve area of
interest (AUC) from unseen data. We used Tenfold cross-validation and the result was averaged to
produce the ROC curve, confusion matrix,

Models Accuracy Class Precision Recall F1 AUC

(PPV) (Sensitivity) Score
Cyst
Normal
PCA
Stone
Tumor
Cyst
Normal
LDA 0.81
Stone
Tumor
Cyst 0.93 0.27 0.42
Normal 0.57 0.94 0.71
HOG 0.57
Stone
Tumor
Cyst 0.99 0.53 0.69
Normal
SIFT 0.75
Stone
Tumor
Cyst
Normal
LDA(SVM)
Stone
Tumor
Cyst
Normal
LBP 7
Stone
Tumor
Table 2. MEASURES OF PERFORMANCE FOR THE SIX MODELS STUDIED IN THE RESEARCH.