Projects Inventory – Page 136 – Projects Inventory Management Systems and Source Codes PHP, C#, C, Android and many others

Functional requirements of Online Reservation System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Management Registration and Authentication: Users can create accounts and log in securely. Include support for various user types (e.g., guests, registered users, administrators). Profile Management: Users can update their personal details, contact information, and preferences. Password Management: Users can reset or change their passwords. Reservation Management Booking: Allow users to search for …

Functional requirements of Online Reservation System with non-functional Read More »

Functional requirements of Recruitment Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Management Registration and Authentication: Users (e.g., recruiters, hiring managers, candidates) can create accounts and log in securely. Role-Based Access Control: Different user roles (e.g., admin, recruiter, interviewer) have specific permissions and access levels. Profile Management: Users can manage their personal information, including updating contact details and preferences. Job Posting and Management Job …

Functional requirements of Recruitment Management System with non-functional Read More »

Queue Implementation Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>

class Queue {
private:
    std::vector<int> data;
    int frontIndex;
    int rearIndex;

public:
    // Constructor to initialize the queue
    Queue() : frontIndex(0), rearIndex(0) {}

    // Method to add an element to the queue
    void enqueue(int value) {
        data.push_back(value);
        rearIndex++;
    }

    // Method to remove and return the front element from the queue
    int dequeue() {
        if (isEmpty()) {
            throw std::out_of_range("Queue is empty");
        }
        int value = data[frontIndex];
        frontIndex++;
        return value;
    }

    // Method to get the front element without removing it
    int front() const {
        if (isEmpty()) {
            throw std::out_of_range("Queue is empty");
        }
        return data[frontIndex];
    }

    // Method to check if the queue is empty
    bool isEmpty() const {
        return frontIndex == rearIndex;
    }

    // Method to get the size of the queue
    int size() const {
        return rearIndex - frontIndex;
    }
};

int main() {
    Queue q;

    // Enqueue elements into the queue
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.enqueue(40);

    std::cout << "Front element: " << q.front() << std::endl;

    // Dequeue elements from the queue
    std::cout << "Dequeued: " << q.dequeue() << std::endl;
    std::cout << "Dequeued: " << q.dequeue() << std::endl;

    std::cout << "Front element after dequeuing: " << q.front() << std::endl;

    std::cout << "Queue size: " << q.size() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

class Queue {

private:

std::vector<int> data;

int frontIndex;

int rearIndex;

public:

// Constructor to initialize the queue

Queue() : frontIndex(0), rearIndex(0) {}

// Method to add an element to the queue

void enqueue(int value) {

data.push_back(value);

rearIndex++;

}

// Method to remove and return the front element from the queue

int dequeue() {

if (isEmpty()) {

throw std::out_of_range("Queue is empty");

}

int value = data[frontIndex];

frontIndex++;

return value;

}

// Method to get the front element without removing it

int front() const {

if (isEmpty()) {

throw std::out_of_range("Queue is empty");

}

return data[frontIndex];

}

// Method to check if the queue is empty

bool isEmpty() const {

return frontIndex == rearIndex;

}

// Method to get the size of the queue

int size() const {

return rearIndex - frontIndex;

}

};

int main() {

Queue q;

// Enqueue elements into the queue

q.enqueue(10);

q.enqueue(20);

q.enqueue(30);

q.enqueue(40);

std::cout << "Front element: " << q.front() << std::endl;

// Dequeue elements from the queue

std::cout << "Dequeued: " << q.dequeue() << std::endl;

std::cout << "Front element after dequeuing: " << q.front() << std::endl;

std::cout << "Queue size: " << q.size() << std::endl;

return 0;

}

Explanation Queue Class: The Queue class is implemented using a std::vector<int> to store the elements. It maintains two indices: frontIndex and rearIndex, which represent the positions of the front and rear elements in the queue. Enqueue Operation: The enqueue(int value) method adds an element to the rear of the queue by pushing it to …

Queue Implementation Gaming Project in C++ Read More »

Quadratic Equation Solver Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <cmath>
#include <complex>

// Function to solve the quadratic equation ax^2 + bx + c = 0
void solveQuadratic(double a, double b, double c) {
    if (a == 0) {
        std::cerr << "This is not a quadratic equation." << std::endl;
        return;
    }

    double discriminant = b * b - 4 * a * c;

    if (discriminant > 0) {
        // Two distinct real roots
        double root1 = (-b + std::sqrt(discriminant)) / (2 * a);
        double root2 = (-b - std::sqrt(discriminant)) / (2 * a);
        std::cout << "Roots are real and different:" << std::endl;
        std::cout << "Root 1 = " << root1 << std::endl;
        std::cout << "Root 2 = " << root2 << std::endl;
    } else if (discriminant == 0) {
        // One real root
        double root = -b / (2 * a);
        std::cout << "Roots are real and the same:" << std::endl;
        std::cout << "Root = " << root << std::endl;
    } else {
        // Complex roots
        std::complex<double> root1 = (-b + std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);
        std::complex<double> root2 = (-b - std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);
        std::cout << "Roots are complex and different:" << std::endl;
        std::cout << "Root 1 = " << root1 << std::endl;
        std::cout << "Root 2 = " << root2 << std::endl;
    }
}

int main() {
    double a, b, c;

    std::cout << "Enter coefficients a, b, and c: ";
    std::cin >> a >> b >> c;

    solveQuadratic(a, b, c);

    return 0;
}

#include <iostream>

#include <cmath>

#include <complex>

// Function to solve the quadratic equation ax^2 + bx + c = 0

void solveQuadratic(double a, double b, double c) {

if (a == 0) {

std::cerr << "This is not a quadratic equation." << std::endl;

return;

}

double discriminant = b * b - 4 * a * c;

if (discriminant > 0) {

// Two distinct real roots

double root1 = (-b + std::sqrt(discriminant)) / (2 * a);

double root2 = (-b - std::sqrt(discriminant)) / (2 * a);

std::cout << "Roots are real and different:" << std::endl;

std::cout << "Root 1 = " << root1 << std::endl;

std::cout << "Root 2 = " << root2 << std::endl;

} else if (discriminant == 0) {

// One real root

double root = -b / (2 * a);

std::cout << "Roots are real and the same:" << std::endl;

std::cout << "Root = " << root << std::endl;

} else {

// Complex roots

std::complex<double> root1 = (-b + std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);

std::complex<double> root2 = (-b - std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);

std::cout << "Roots are complex and different:" << std::endl;

std::cout << "Root 1 = " << root1 << std::endl;

std::cout << "Root 2 = " << root2 << std::endl;

}

int main() {

double a, b, c;

std::cout << "Enter coefficients a, b, and c: ";

std::cin >> a >> b >> c;

solveQuadratic(a, b, c);

return 0;

}

Explanation Quadratic Equation: The general form of a quadratic equation is ax2+bx+c=0ax^2 + bx + c = 0ax2+bx+c=0, where aaa, bbb, and ccc are coefficients. Discriminant: The discriminant of the quadratic equation is calculated as discriminant=b2−4ac\text{discriminant} = b^2 – 4acdiscriminant=b2−4ac. The nature of the roots depends on the discriminant: If the discriminant is positive, …

Quadratic Equation Solver Gaming Project in C++ Read More »

Priority Queue Implementation Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <algorithm>

// A class to represent a priority queue
class PriorityQueue {
private:
    std::vector<int> data;

    // Helper function to heapify the tree
    void heapify_up(int index) {
        if (index == 0) return; // Base case: root node
        int parent = (index - 1) / 2;

        if (data[index] > data[parent]) {
            std::swap(data[index], data[parent]);
            heapify_up(parent);
        }
    }

    void heapify_down(int index) {
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        int largest = index;

        if (leftChild < data.size() && data[leftChild] > data[largest]) {
            largest = leftChild;
        }

        if (rightChild < data.size() && data[rightChild] > data[largest]) {
            largest = rightChild;
        }

        if (largest != index) {
            std::swap(data[index], data[largest]);
            heapify_down(largest);
        }
    }

public:
    // Insert a new element into the priority queue
    void push(int value) {
        data.push_back(value);
        heapify_up(data.size() - 1);
    }

    // Remove and return the highest priority element
    int pop() {
        if (data.empty()) {
            throw std::out_of_range("Priority Queue is empty");
        }
        int root = data.front();
        data[0] = data.back();
        data.pop_back();
        heapify_down(0);
        return root;
    }

    // Return the highest priority element without removing it
    int top() const {
        if (data.empty()) {
            throw std::out_of_range("Priority Queue is empty");
        }
        return data.front();
    }

    // Check if the priority queue is empty
    bool empty() const {
        return data.empty();
    }
};

int main() {
    PriorityQueue pq;

    // Inserting elements into the priority queue
    pq.push(5);
    pq.push(15);
    pq.push(10);
    pq.push(30);
    pq.push(20);

    std::cout << "Top element: " << pq.top() << std::endl;

    // Removing elements from the priority queue
    std::cout << "Popped element: " << pq.pop() << std::endl;
    std::cout << "Popped element: " << pq.pop() << std::endl;

    std::cout << "Top element after popping: " << pq.top() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <algorithm>

// A class to represent a priority queue

class PriorityQueue {

private:

std::vector<int> data;

// Helper function to heapify the tree

void heapify_up(int index) {

if (index == 0) return; // Base case: root node

int parent = (index - 1) / 2;

if (data[index] > data[parent]) {

std::swap(data[index], data[parent]);

heapify_up(parent);

}

void heapify_down(int index) {

int leftChild = 2 * index + 1;

int rightChild = 2 * index + 2;

int largest = index;

if (leftChild < data.size() && data[leftChild] > data[largest]) {

largest = leftChild;

}

if (rightChild < data.size() && data[rightChild] > data[largest]) {

largest = rightChild;

}

if (largest != index) {

std::swap(data[index], data[largest]);

heapify_down(largest);

}

public:

// Insert a new element into the priority queue

void push(int value) {

data.push_back(value);

heapify_up(data.size() - 1);

}

// Remove and return the highest priority element

int pop() {

if (data.empty()) {

throw std::out_of_range("Priority Queue is empty");

}

int root = data.front();

data[0] = data.back();

data.pop_back();

heapify_down(0);

return root;

}

// Return the highest priority element without removing it

int top() const {

if (data.empty()) {

throw std::out_of_range("Priority Queue is empty");

}

return data.front();

}

// Check if the priority queue is empty

bool empty() const {

return data.empty();

}

};

int main() {

PriorityQueue pq;

// Inserting elements into the priority queue

pq.push(5);

pq.push(15);

pq.push(10);

pq.push(30);

pq.push(20);

std::cout << "Top element: " << pq.top() << std::endl;

// Removing elements from the priority queue

std::cout << "Popped element: " << pq.pop() << std::endl;

std::cout << "Top element after popping: " << pq.top() << std::endl;

return 0;

}

Explanation Priority Queue Class: The PriorityQueue class uses a vector (std::vector<int> data) to store the elements. It maintains a max-heap, where the highest priority element is always at the root (index 0). heapify_up: This method ensures the heap property is maintained after inserting a new element by comparing the newly added element with its …

Priority Queue Implementation Gaming Project in C++ Read More »

Photo Viewer Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <filesystem>

namespace fs = std::filesystem;

void showImage(const cv::Mat& image, const std::string& windowName) {
    cv::imshow(windowName, image);
    cv::waitKey(0); // Wait for a key press
}

std::vector<std::string> loadImagePaths(const std::string& directory) {
    std::vector<std::string> imagePaths;
    for (const auto& entry : fs::directory_iterator(directory)) {
        if (entry.is_regular_file() && (entry.path().extension() == ".jpg" ||
                                        entry.path().extension() == ".png" ||
                                        entry.path().extension() == ".bmp")) {
            imagePaths.push_back(entry.path().string());
        }
    }
    return imagePaths;
}

int main() {
    std::string directory;
    std::cout << "Enter the directory path containing images: ";
    std::cin >> directory;

    std::vector<std::string> imagePaths = loadImagePaths(directory);

    if (imagePaths.empty()) {
        std::cout << "No images found in the directory.\n";
        return 1;
    }

    int index = 0;
    while (true) {
        cv::Mat image = cv::imread(imagePaths[index]);
        if (image.empty()) {
            std::cerr << "Error loading image: " << imagePaths[index] << std::endl;
            return 1;
        }

        showImage(image, "Photo Viewer");

        std::cout << "Press 'n' for next image, 'p' for previous image, or 'q' to quit.\n";
        char key = static_cast<char>(cv::waitKey(0));
        if (key == 'n') {
            index = (index + 1) % imagePaths.size();
        } else if (key == 'p') {
            index = (index - 1 + imagePaths.size()) % imagePaths.size();
        } else if (key == 'q') {
            break;
        } else {
            std::cout << "Invalid key. Use 'n', 'p', or 'q'.\n";
        }
    }

    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

#include <vector>

#include <filesystem>

namespace fs = std::filesystem;

void showImage(const cv::Mat& image, const std::string& windowName) {

cv::imshow(windowName, image);

cv::waitKey(0); // Wait for a key press

}

std::vector<std::string> loadImagePaths(const std::string& directory) {

std::vector<std::string> imagePaths;

for (const auto& entry : fs::directory_iterator(directory)) {

if (entry.is_regular_file() && (entry.path().extension() == ".jpg" ||

entry.path().extension() == ".png" ||

entry.path().extension() == ".bmp")) {

imagePaths.push_back(entry.path().string());

}

return imagePaths;

}

int main() {

std::string directory;

std::cout << "Enter the directory path containing images: ";

std::cin >> directory;

std::vector<std::string> imagePaths = loadImagePaths(directory);

if (imagePaths.empty()) {

std::cout << "No images found in the directory.\n";

return 1;

}

int index = 0;

while (true) {

cv::Mat image = cv::imread(imagePaths[index]);

if (image.empty()) {

std::cerr << "Error loading image: " << imagePaths[index] << std::endl;

return 1;

}

showImage(image, "Photo Viewer");

std::cout << "Press 'n' for next image, 'p' for previous image, or 'q' to quit.\n";

char key = static_cast<char>(cv::waitKey(0));

if (key == 'n') {

index = (index + 1) % imagePaths.size();

} else if (key == 'p') {

index = (index - 1 + imagePaths.size()) % imagePaths.size();

} else if (key == 'q') {

break;

} else {

std::cout << "Invalid key. Use 'n', 'p', or 'q'.\n";

}

cv::destroyAllWindows();

return 0;

}

Explanation: Include OpenCV and Standard Libraries: #include <opencv2/opencv.hpp>: Includes the OpenCV core functionalities. #include <iostream>: For input and output operations. #include <vector>: For using the std::vector container. #include <filesystem>: For directory and file handling in C++17. Show Image Function: showImage(const cv::Mat& image, const std::string& windowName): Displays the image in a window named windowName. The …

Photo Viewer Gaming Project in C++ Read More »

Password Manager Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <fstream>
#include <string>
#include <map>

void addPassword(std::map<std::string, std::string>& passwords) {
    std::string account, password;
    std::cout << "Enter account name: ";
    std::cin.ignore();
    std::getline(std::cin, account);
    std::cout << "Enter password: ";
    std::getline(std::cin, password);
    passwords[account] = password;
    std::cout << "Password added successfully.\n";
}

void viewPasswords(const std::map<std::string, std::string>& passwords) {
    if (passwords.empty()) {
        std::cout << "No passwords stored.\n";
        return;
    }
    std::cout << "Stored passwords:\n";
    for (const auto& entry : passwords) {
        std::cout << "Account: " << entry.first << " | Password: " << entry.second << '\n';
    }
}

void savePasswords(const std::map<std::string, std::string>& passwords) {
    std::ofstream file("passwords.txt");
    if (!file) {
        std::cerr << "Error opening file for writing.\n";
        return;
    }
    for (const auto& entry : passwords) {
        file << entry.first << '\n' << entry.second << '\n';
    }
    file.close();
    std::cout << "Passwords saved successfully.\n";
}

void loadPasswords(std::map<std::string, std::string>& passwords) {
    std::ifstream file("passwords.txt");
    if (!file) {
        std::cerr << "Error opening file for reading.\n";
        return;
    }
    std::string account, password;
    while (std::getline(file, account) && std::getline(file, password)) {
        passwords[account] = password;
    }
    file.close();
}

int main() {
    std::map<std::string, std::string> passwords;
    loadPasswords(passwords);

    int choice;
    while (true) {
        std::cout << "Password Manager\n";
        std::cout << "1. Add Password\n";
        std::cout << "2. View Passwords\n";
        std::cout << "3. Save and Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                addPassword(passwords);
                break;
            case 2:
                viewPasswords(passwords);
                break;
            case 3:
                savePasswords(passwords);
                return 0;
            default:
                std::cout << "Invalid choice. Please try again.\n";
        }
    }

    return 0;
}

#include <iostream>

#include <fstream>

#include <string>

#include <map>

void addPassword(std::map<std::string, std::string>& passwords) {

std::string account, password;

std::cout << "Enter account name: ";

std::cin.ignore();

std::getline(std::cin, account);

std::cout << "Enter password: ";

std::getline(std::cin, password);

passwords[account] = password;

std::cout << "Password added successfully.\n";

}

void viewPasswords(const std::map<std::string, std::string>& passwords) {

if (passwords.empty()) {

std::cout << "No passwords stored.\n";

return;

}

std::cout << "Stored passwords:\n";

for (const auto& entry : passwords) {

std::cout << "Account: " << entry.first << " | Password: " << entry.second << '\n';

}

void savePasswords(const std::map<std::string, std::string>& passwords) {

std::ofstream file("passwords.txt");

if (!file) {

std::cerr << "Error opening file for writing.\n";

return;

}

for (const auto& entry : passwords) {

file << entry.first << '\n' << entry.second << '\n';

}

file.close();

std::cout << "Passwords saved successfully.\n";

}

void loadPasswords(std::map<std::string, std::string>& passwords) {

std::ifstream file("passwords.txt");

if (!file) {

std::cerr << "Error opening file for reading.\n";

return;

}

std::string account, password;

while (std::getline(file, account) && std::getline(file, password)) {

passwords[account] = password;

}

file.close();

}

int main() {

std::map<std::string, std::string> passwords;

loadPasswords(passwords);

int choice;

while (true) {

std::cout << "Password Manager\n";

std::cout << "1. Add Password\n";

std::cout << "2. View Passwords\n";

std::cout << "3. Save and Exit\n";

std::cout << "Enter your choice: ";

std::cin >> choice;

switch (choice) {

case 1:

addPassword(passwords);

break;

case 2:

viewPasswords(passwords);

break;

case 3:

savePasswords(passwords);

return 0;

default:

std::cout << "Invalid choice. Please try again.\n";

}

return 0;

}

Explanation: Include Headers: #include <iostream>: For input and output operations. #include <fstream>: For file operations. #include <string>: For string manipulations. #include <map>: For using the std::map container to store account-password pairs. Functions: addPassword: Prompts the user to enter an account name and password, then stores these in the passwords map. viewPasswords: Displays all stored …

Password Manager Gaming Project in C++ Read More »

Optical Character Recognition (OCR) Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>

int main() {
    // Initialize Tesseract API
    tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();
    if (api->Init(NULL, "eng")) {  // Initialize with the English language
        std::cerr << "Could not initialize tesseract.\n";
        return 1;
    }

    // Load an image from file
    Pix *image = pixRead("image.png");  // Replace with your image file path
    if (image == NULL) {
        std::cerr << "Could not open image file.\n";
        api->End();
        return 1;
    }

    // Set the image for OCR processing
    api->SetImage(image);

    // Perform OCR
    char *text = api->GetUTF8Text();
    if (text == NULL) {
        std::cerr << "Could not perform OCR.\n";
        pixDestroy(&image);
        api->End();
        return 1;
    }

    // Output the extracted text
    std::cout << "Extracted Text:\n" << text << std::endl;

    // Clean up
    delete[] text;
    pixDestroy(&image);
    api->End();

    return 0;
}

#include <iostream>

#include <tesseract/baseapi.h>

#include <leptonica/allheaders.h>

int main() {

// Initialize Tesseract API

tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();

if (api->Init(NULL, "eng")) { // Initialize with the English language

std::cerr << "Could not initialize tesseract.\n";

return 1;

}

// Load an image from file

Pix *image = pixRead("image.png"); // Replace with your image file path

if (image == NULL) {

std::cerr << "Could not open image file.\n";

api->End();

return 1;

}

// Set the image for OCR processing

api->SetImage(image);

// Perform OCR

char *text = api->GetUTF8Text();

if (text == NULL) {

std::cerr << "Could not perform OCR.\n";

pixDestroy(&image);

api->End();

return 1;

}

// Output the extracted text

std::cout << "Extracted Text:\n" << text << std::endl;

// Clean up

delete[] text;

pixDestroy(&image);

api->End();

return 0;

}

Explanation: Include Tesseract and Leptonica Headers: #include <tesseract/baseapi.h>: Includes the Tesseract API for OCR. #include <leptonica/allheaders.h>: Includes Leptonica library headers for image processing. Initialize Tesseract API: tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();: Creates an instance of the Tesseract API. api->Init(NULL, “eng”);: Initializes the Tesseract API with the English language. You may specify the path to …

Optical Character Recognition (OCR) Gaming Project in C++ Read More »

Object Detection Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // Load the pre-trained Haar Cascade for face detection
    cv::CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        std::cerr << "Error loading Haar Cascade file!" << std::endl;
        return -1;
    }

    // Open a video capture from the default camera
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "Error opening video capture!" << std::endl;
        return -1;
    }

    cv::Mat frame;
    std::vector<cv::Rect> faces;

    while (true) {
        // Capture a new frame from the video feed
        cap >> frame;
        if (frame.empty()) {
            std::cerr << "Error capturing frame!" << std::endl;
            break;
        }

        // Convert the frame to grayscale
        cv::Mat gray;
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);

        // Detect faces in the frame
        faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, cv::Size(30, 30));

        // Draw rectangles around detected faces
        for (const auto& face : faces) {
            cv::rectangle(frame, face, cv::Scalar(255, 0, 0), 2);
        }

        // Display the frame with detected faces
        cv::imshow("Object Detection", frame);

        // Exit loop when 'q' is pressed
        if (cv::waitKey(30) >= 0) {
            break;
        }
    }

    // Release video capture and close windows
    cap.release();
    cv::destroyAllWindows();

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

int main() {

// Load the pre-trained Haar Cascade for face detection

cv::CascadeClassifier faceCascade;

if (!faceCascade.load("haarcascade_frontalface_default.xml")) {

std::cerr << "Error loading Haar Cascade file!" << std::endl;

return -1;

}

// Open a video capture from the default camera

cv::VideoCapture cap(0);

if (!cap.isOpened()) {

std::cerr << "Error opening video capture!" << std::endl;

return -1;

}

cv::Mat frame;

std::vector<cv::Rect> faces;

while (true) {

// Capture a new frame from the video feed

cap >> frame;

if (frame.empty()) {

std::cerr << "Error capturing frame!" << std::endl;

break;

}

// Convert the frame to grayscale

cv::Mat gray;

cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);

// Detect faces in the frame

faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, cv::Size(30, 30));

// Draw rectangles around detected faces

for (const auto& face : faces) {

cv::rectangle(frame, face, cv::Scalar(255, 0, 0), 2);

}

// Display the frame with detected faces

cv::imshow("Object Detection", frame);

// Exit loop when 'q' is pressed

if (cv::waitKey(30) >= 0) {

break;

}

// Release video capture and close windows

cap.release();

cv::destroyAllWindows();

return 0;

}

Explanation: Include OpenCV Header: #include <opencv2/opencv.hpp>: Includes the OpenCV core functionalities. Load Haar Cascade: cv::CascadeClassifier faceCascade;: Creates an object to load and use Haar cascade classifiers. faceCascade.load(“haarcascade_frontalface_default.xml”);: Loads the pre-trained Haar cascade for face detection. Ensure that the haarcascade_frontalface_default.xml file is available in your working directory or provide the correct path. Capture Video: cv::VideoCapture …

Object Detection Gaming Project in C++ Read More »

Functional requirements of Appointment Scheduling System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Management Registration and Authentication: Users can create accounts and log in securely. This includes support for various user types such as patients, staff, and administrators. Profile Management: Users can update their personal details, contact information, and preferences. Role-Based Access Control: Different roles (e.g., admin, receptionist, healthcare provider) have different levels of access …

Functional requirements of Appointment Scheduling System with non-functional Read More »