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

Binary Search Tree (BST) Implementation Gaming Project in C++

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

#include <iostream>

using namespace std;

// Node structure for the Binary Search Tree
struct Node {
    int data;
    Node* left;
    Node* right;

    Node(int value) : data(value), left(nullptr), right(nullptr) {}
};

// Binary Search Tree class
class BST {
public:
    BST() : root(nullptr) {}

    // Insert a new value into the BST
    void insert(int value) {
        root = insertRec(root, value);
    }

    // Perform in-order traversal of the BST
    void inorder() const {
        inorderRec(root);
        cout << endl;
    }

    // Search for a value in the BST
    bool search(int value) const {
        return searchRec(root, value);
    }

private:
    Node* root;

    // Recursive insert function
    Node* insertRec(Node* node, int value) {
        if (node == nullptr) {
            return new Node(value);
        }
        if (value < node->data) {
            node->left = insertRec(node->left, value);
        } else if (value > node->data) {
            node->right = insertRec(node->right, value);
        }
        return node;
    }

    // Recursive in-order traversal function
    void inorderRec(Node* node) const {
        if (node != nullptr) {
            inorderRec(node->left);
            cout << node->data << " ";
            inorderRec(node->right);
        }
    }

    // Recursive search function
    bool searchRec(Node* node, int value) const {
        if (node == nullptr) {
            return false;
        }
        if (value == node->data) {
            return true;
        }
        if (value < node->data) {
            return searchRec(node->left, value);
        }
        return searchRec(node->right, value);
    }
};

int main() {
    BST tree;

    // Insert values into the BST
    tree.insert(50);
    tree.insert(30);
    tree.insert(20);
    tree.insert(40);
    tree.insert(70);
    tree.insert(60);
    tree.insert(80);

    // Perform in-order traversal
    cout << "In-order traversal: ";
    tree.inorder();

    // Search for values in the BST
    int searchValue = 40;
    if (tree.search(searchValue)) {
        cout << searchValue << " is present in the BST." << endl;
    } else {
        cout << searchValue << " is not present in the BST." << endl;
    }

    searchValue = 90;
    if (tree.search(searchValue)) {
        cout << searchValue << " is present in the BST." << endl;
    } else {
        cout << searchValue << " is not present in the BST." << endl;
    }

    return 0;
}

100

101

102

103

104

105

106

107

#include <iostream>

using namespace std;

// Node structure for the Binary Search Tree

struct Node {

int data;

Node* left;

Node* right;

Node(int value) : data(value), left(nullptr), right(nullptr) {}

};

// Binary Search Tree class

class BST {

public:

BST() : root(nullptr) {}

// Insert a new value into the BST

void insert(int value) {

root = insertRec(root, value);

}

// Perform in-order traversal of the BST

void inorder() const {

inorderRec(root);

cout << endl;

}

// Search for a value in the BST

bool search(int value) const {

return searchRec(root, value);

}

private:

Node* root;

// Recursive insert function

Node* insertRec(Node* node, int value) {

if (node == nullptr) {

return new Node(value);

}

if (value < node->data) {

node->left = insertRec(node->left, value);

} else if (value > node->data) {

node->right = insertRec(node->right, value);

}

return node;

}

// Recursive in-order traversal function

void inorderRec(Node* node) const {

if (node != nullptr) {

inorderRec(node->left);

cout << node->data << " ";

inorderRec(node->right);

}

// Recursive search function

bool searchRec(Node* node, int value) const {

if (node == nullptr) {

return false;

}

if (value == node->data) {

return true;

}

if (value < node->data) {

return searchRec(node->left, value);

}

return searchRec(node->right, value);

}

};

int main() {

BST tree;

// Insert values into the BST

tree.insert(50);

tree.insert(30);

tree.insert(20);

tree.insert(40);

tree.insert(70);

tree.insert(60);

tree.insert(80);

// Perform in-order traversal

cout << "In-order traversal: ";

tree.inorder();

// Search for values in the BST

int searchValue = 40;

if (tree.search(searchValue)) {

cout << searchValue << " is present in the BST." << endl;

} else {

cout << searchValue << " is not present in the BST." << endl;

}

searchValue = 90;

if (tree.search(searchValue)) {

cout << searchValue << " is present in the BST." << endl;

} else {

cout << searchValue << " is not present in the BST." << endl;

}

return 0;

}

Explanation Node Structure: struct Node defines the structure of a node in the BST. int data: Stores the value of the node. Node* left: Pointer to the left child. Node* right: Pointer to the right child. Node(int value): Constructor to initialize a node with a given value and set child pointers to nullptr. BST …

Binary Search Tree (BST) Implementation Gaming Project in C++ Read More »

Basic Web Browser Gaming Project in C++

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

#include <QApplication>
#include <QMainWindow>
#include <QWebEngineView>
#include <QLineEdit>
#include <QVBoxLayout>
#include <QPushButton>

class Browser : public QMainWindow {
    Q_OBJECT

public:
    Browser() {
        // Create main widget and layout
        QWidget *mainWidget = new QWidget(this);
        QVBoxLayout *layout = new QVBoxLayout(mainWidget);

        // Create URL input field
        urlField = new QLineEdit(this);
        urlField->setPlaceholderText("Enter URL");

        // Create web view
        webView = new QWebEngineView(this);

        // Create navigation button
        QPushButton *goButton = new QPushButton("Go", this);

        // Connect button click to URL loading
        connect(goButton, &QPushButton::clicked, this, &Browser::loadUrl);

        // Add widgets to layout
        layout->addWidget(urlField);
        layout->addWidget(goButton);
        layout->addWidget(webView);

        // Set the layout and central widget
        mainWidget->setLayout(layout);
        setCentralWidget(mainWidget);
        setWindowTitle("Basic Web Browser");
        resize(1024, 768);
    }

private slots:
    void loadUrl() {
        QString url = urlField->text();
        if (!url.startsWith("http://") && !url.startsWith("https://")) {
            url.prepend("http://");
        }
        webView->setUrl(QUrl(url));
    }

private:
    QLineEdit *urlField;
    QWebEngineView *webView;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    Browser browser;
    browser.show();
    return app.exec();
}

#include <QApplication>

#include <QMainWindow>

#include <QWebEngineView>

#include <QLineEdit>

#include <QVBoxLayout>

#include <QPushButton>

class Browser : public QMainWindow {

Q_OBJECT

public:

Browser() {

// Create main widget and layout

QWidget *mainWidget = new QWidget(this);

QVBoxLayout *layout = new QVBoxLayout(mainWidget);

// Create URL input field

urlField = new QLineEdit(this);

urlField->setPlaceholderText("Enter URL");

// Create web view

webView = new QWebEngineView(this);

// Create navigation button

QPushButton *goButton = new QPushButton("Go", this);

// Connect button click to URL loading

connect(goButton, &QPushButton::clicked, this, &Browser::loadUrl);

// Add widgets to layout

layout->addWidget(urlField);

layout->addWidget(goButton);

layout->addWidget(webView);

// Set the layout and central widget

mainWidget->setLayout(layout);

setCentralWidget(mainWidget);

setWindowTitle("Basic Web Browser");

resize(1024, 768);

}

private slots:

void loadUrl() {

QString url = urlField->text();

if (!url.startsWith("http://") && !url.startsWith("https://")) {

url.prepend("http://");

}

webView->setUrl(QUrl(url));

}

private:

QLineEdit *urlField;

QWebEngineView *webView;

};

int main(int argc, char *argv[]) {

QApplication app(argc, argv);

Browser browser;

browser.show();

return app.exec();

}

Explanation Include Qt Headers: #include <QApplication>: Manages application-wide resources and settings. #include <QMainWindow>: Provides a main application window. #include <QWebEngineView>: Displays web content. (Requires Qt WebEngine module) #include <QLineEdit>: Provides a text input field. #include <QVBoxLayout>: Layout manager for arranging widgets vertically. #include <QPushButton>: Provides a clickable button. Browser Class: Inherits from QMainWindow: Allows …

Basic Web Browser Gaming Project in C++ Read More »

Basic GUI Library Gaming Project in C++

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

#include <SFML/Graphics.hpp>

int main() {
    // Create a window
    sf::RenderWindow window(sf::VideoMode(800, 600), "Basic GUI with SFML");

    // Create a circle shape
    sf::CircleShape circle(50); // radius 50
    circle.setFillColor(sf::Color::Green); // Fill color
    circle.setPosition(375, 275); // Center the circle

    // Create a rectangle shape
    sf::RectangleShape rectangle(sf::Vector2f(200, 100)); // Width and height
    rectangle.setFillColor(sf::Color::Blue); // Fill color
    rectangle.setPosition(300, 250); // Center the rectangle

    // Main loop
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        // Clear the window with black color
        window.clear(sf::Color::Black);

        // Draw the shapes
        window.draw(circle);
        window.draw(rectangle);

        // Display everything we have drawn
        window.display();
    }

    return 0;
}

#include <SFML/Graphics.hpp>

int main() {

// Create a window

sf::RenderWindow window(sf::VideoMode(800, 600), "Basic GUI with SFML");

// Create a circle shape

sf::CircleShape circle(50); // radius 50

circle.setFillColor(sf::Color::Green); // Fill color

circle.setPosition(375, 275); // Center the circle

// Create a rectangle shape

sf::RectangleShape rectangle(sf::Vector2f(200, 100)); // Width and height

rectangle.setFillColor(sf::Color::Blue); // Fill color

rectangle.setPosition(300, 250); // Center the rectangle

// Main loop

while (window.isOpen()) {

sf::Event event;

while (window.pollEvent(event)) {

if (event.type == sf::Event::Closed) {

window.close();

}

// Clear the window with black color

window.clear(sf::Color::Black);

// Draw the shapes

window.draw(circle);

window.draw(rectangle);

// Display everything we have drawn

window.display();

}

return 0;

}

Explanation Include SFML Library: #include <SFML/Graphics.hpp>: Includes SFML’s graphics module, which provides functionality for creating and manipulating graphics. Create a Window: sf::RenderWindow window(sf::VideoMode(800, 600), “Basic GUI with SFML”); Initializes a window with a resolution of 800×600 pixels and a title “Basic GUI with SFML”. Create and Configure Shapes: Circle: sf::CircleShape circle(50);: Creates a circle …

Basic GUI Library Gaming Project in C++ Read More »

Basic Graph Algorithms (DFS, BFS) Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

class Graph {
private:
    int V; // Number of vertices
    vector<vector<int>> adj; // Adjacency list

public:
    Graph(int vertices) : V(vertices), adj(vertices) {}

    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u); // For undirected graph
    }

    void DFS(int start) const {
        vector<bool> visited(V, false);
        stack<int> s;
        s.push(start);

        while (!s.empty()) {
            int node = s.top();
            s.pop();

            if (!visited[node]) {
                cout << node << " ";
                visited[node] = true;
            }

            for (int neighbor : adj[node]) {
                if (!visited[neighbor]) {
                    s.push(neighbor);
                }
            }
        }
        cout << endl;
    }

    void BFS(int start) const {
        vector<bool> visited(V, false);
        queue<int> q;
        q.push(start);
        visited[start] = true;

        while (!q.empty()) {
            int node = q.front();
            q.pop();
            cout << node << " ";

            for (int neighbor : adj[node]) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    q.push(neighbor);
                }
            }
        }
        cout << endl;
    }
};

int main() {
    int vertices = 6; // Number of vertices
    Graph g(vertices);

    // Adding edges to the graph
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 3);
    g.addEdge(1, 4);
    g.addEdge(2, 5);

    cout << "DFS starting from vertex 0: ";
    g.DFS(0);

    cout << "BFS starting from vertex 0: ";
    g.BFS(0);

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <stack>

using namespace std;

class Graph {

private:

int V; // Number of vertices

vector<vector<int>> adj; // Adjacency list

public:

Graph(int vertices) : V(vertices), adj(vertices) {}

void addEdge(int u, int v) {

adj[u].push_back(v);

adj[v].push_back(u); // For undirected graph

}

void DFS(int start) const {

vector<bool> visited(V, false);

stack<int> s;

s.push(start);

while (!s.empty()) {

int node = s.top();

s.pop();

if (!visited[node]) {

cout << node << " ";

visited[node] = true;

}

for (int neighbor : adj[node]) {

if (!visited[neighbor]) {

s.push(neighbor);

}

cout << endl;

}

void BFS(int start) const {

vector<bool> visited(V, false);

queue<int> q;

q.push(start);

visited[start] = true;

while (!q.empty()) {

int node = q.front();

q.pop();

cout << node << " ";

for (int neighbor : adj[node]) {

if (!visited[neighbor]) {

visited[neighbor] = true;

q.push(neighbor);

}

cout << endl;

}

};

int main() {

int vertices = 6; // Number of vertices

Graph g(vertices);

// Adding edges to the graph

g.addEdge(0, 1);

g.addEdge(0, 2);

g.addEdge(1, 3);

g.addEdge(1, 4);

g.addEdge(2, 5);

cout << "DFS starting from vertex 0: ";

g.DFS(0);

cout << "BFS starting from vertex 0: ";

g.BFS(0);

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <vector>: For using dynamic arrays (vectors). #include <queue>: For the BFS implementation. #include <stack>: For the DFS implementation. Graph Class: Private Data Members: V: Number of vertices. adj: Adjacency list representation of the graph, where each vertex has a list of its neighbors. …

Basic Graph Algorithms (DFS, BFS) Gaming Project in C++ Read More »

Basic Compiler Design Gaming Project in C++

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

#include <iostream>
#include <string>
#include <cctype>
#include <stdexcept>
#include <map>

using namespace std;

// Token types
enum class TokenType {
    NUMBER,
    PLUS,
    MINUS,
    MULTIPLY,
    DIVIDE,
    END,
    INVALID
};

// Token structure
struct Token {
    TokenType type;
    int value; // For NUMBER token
};

// Lexer class
class Lexer {
public:
    Lexer(const string& text) : text(text), pos(0), currentChar(text[pos]) {}

    Token getNextToken() {
        while (currentChar != '\0') {
            if (isspace(currentChar)) {
                skipWhitespace();
                continue;
            }

            if (isdigit(currentChar)) {
                return Token{TokenType::NUMBER, getNumber()};
            }

            if (currentChar == '+') {
                advance();
                return Token{TokenType::PLUS, 0};
            }

            if (currentChar == '-') {
                advance();
                return Token{TokenType::MINUS, 0};
            }

            if (currentChar == '*') {
                advance();
                return Token{TokenType::MULTIPLY, 0};
            }

            if (currentChar == '/') {
                advance();
                return Token{TokenType::DIVIDE, 0};
            }

            throw runtime_error("Invalid character");
        }

        return Token{TokenType::END, 0};
    }

private:
    string text;
    size_t pos;
    char currentChar;

    void advance() {
        ++pos;
        if (pos >= text.length()) {
            currentChar = '\0';
        } else {
            currentChar = text[pos];
        }
    }

    void skipWhitespace() {
        while (currentChar != '\0' && isspace(currentChar)) {
            advance();
        }
    }

    int getNumber() {
        string number;
        while (currentChar != '\0' && isdigit(currentChar)) {
            number += currentChar;
            advance();
        }
        return stoi(number);
    }
};

// Parser class
class Parser {
public:
    Parser(Lexer lexer) : lexer(lexer), currentToken(lexer.getNextToken()) {}

    int parse() {
        int result = expression();
        if (currentToken.type != TokenType::END) {
            throw runtime_error("Unexpected token after end of expression");
        }
        return result;
    }

private:
    Lexer lexer;
    Token currentToken;

    void eat(TokenType type) {
        if (currentToken.type == type) {
            currentToken = lexer.getNextToken();
        } else {
            throw runtime_error("Unexpected token type");
        }
    }

    int factor() {
        if (currentToken.type == TokenType::NUMBER) {
            int value = currentToken.value;
            eat(TokenType::NUMBER);
            return value;
        }
        throw runtime_error("Expected number");
    }

    int term() {
        int result = factor();
        while (currentToken.type == TokenType::MULTIPLY || currentToken.type == TokenType::DIVIDE) {
            TokenType op = currentToken.type;
            eat(op);
            if (op == TokenType::MULTIPLY) {
                result *= factor();
            } else {
                result /= factor();
            }
        }
        return result;
    }

    int expression() {
        int result = term();
        while (currentToken.type == TokenType::PLUS || currentToken.type == TokenType::MINUS) {
            TokenType op = currentToken.type;
            eat(op);
            if (op == TokenType::PLUS) {
                result += term();
            } else {
                result -= term();
            }
        }
        return result;
    }
};

int main() {
    string text;
    cout << "Enter an arithmetic expression: ";
    getline(cin, text);

    try {
        Lexer lexer(text);
        Parser parser(lexer);
        int result = parser.parse();
        cout << "Result: " << result << endl;
    } catch (const runtime_error& e) {
        cerr << "Error: " << e.what() << endl;
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

#include <iostream>

#include <string>

#include <cctype>

#include <stdexcept>

#include <map>

using namespace std;

// Token types

enum class TokenType {

NUMBER,

PLUS,

MINUS,

MULTIPLY,

DIVIDE,

END,

INVALID

};

// Token structure

struct Token {

TokenType type;

int value; // For NUMBER token

};

// Lexer class

class Lexer {

public:

Lexer(const string& text) : text(text), pos(0), currentChar(text[pos]) {}

Token getNextToken() {

while (currentChar != '\0') {

if (isspace(currentChar)) {

skipWhitespace();

continue;

}

if (isdigit(currentChar)) {

return Token{TokenType::NUMBER, getNumber()};

}

if (currentChar == '+') {

advance();

return Token{TokenType::PLUS, 0};

}

if (currentChar == '-') {

advance();

return Token{TokenType::MINUS, 0};

}

if (currentChar == '*') {

advance();

return Token{TokenType::MULTIPLY, 0};

}

if (currentChar == '/') {

advance();

return Token{TokenType::DIVIDE, 0};

}

throw runtime_error("Invalid character");

}

return Token{TokenType::END, 0};

}

private:

string text;

size_t pos;

char currentChar;

void advance() {

++pos;

if (pos >= text.length()) {

currentChar = '\0';

} else {

currentChar = text[pos];

}

void skipWhitespace() {

while (currentChar != '\0' && isspace(currentChar)) {

advance();

}

int getNumber() {

string number;

while (currentChar != '\0' && isdigit(currentChar)) {

number += currentChar;

advance();

}

return stoi(number);

}

};

// Parser class

class Parser {

public:

Parser(Lexer lexer) : lexer(lexer), currentToken(lexer.getNextToken()) {}

int parse() {

int result = expression();

if (currentToken.type != TokenType::END) {

throw runtime_error("Unexpected token after end of expression");

}

return result;

}

private:

Lexer lexer;

Token currentToken;

void eat(TokenType type) {

if (currentToken.type == type) {

currentToken = lexer.getNextToken();

} else {

throw runtime_error("Unexpected token type");

}

int factor() {

if (currentToken.type == TokenType::NUMBER) {

int value = currentToken.value;

eat(TokenType::NUMBER);

return value;

}

throw runtime_error("Expected number");

}

int term() {

int result = factor();

while (currentToken.type == TokenType::MULTIPLY || currentToken.type == TokenType::DIVIDE) {

TokenType op = currentToken.type;

eat(op);

if (op == TokenType::MULTIPLY) {

result *= factor();

} else {

result /= factor();

}

return result;

}

int expression() {

int result = term();

while (currentToken.type == TokenType::PLUS || currentToken.type == TokenType::MINUS) {

TokenType op = currentToken.type;

eat(op);

if (op == TokenType::PLUS) {

result += term();

} else {

result -= term();

}

return result;

}

};

int main() {

string text;

cout << "Enter an arithmetic expression: ";

getline(cin, text);

try {

Lexer lexer(text);

Parser parser(lexer);

int result = parser.parse();

cout << "Result: " << result << endl;

} catch (const runtime_error& e) {

cerr << "Error: " << e.what() << endl;

}

return 0;

}

Explanation Token Types: TokenType is an enum class that defines different types of tokens: NUMBER, PLUS, MINUS, MULTIPLY, DIVIDE, END, and INVALID. Token Structure: Token holds the type of token and its value (if it’s a number). Lexer Class: Purpose: Breaks the input text into tokens. Methods: getNextToken(): Reads characters from the input and …

Basic Compiler Design Gaming Project in C++ Read More »

Barcode Reader Gaming Project in C++

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

#include <iostream>
#include <opencv2/opencv.hpp>
#include <zxing/BarcodeFormat.h>
#include <zxing/DecodeHints.h>
#include <zxing/Reader.h>
#include <zxing/MultiFormatReader.h>
#include <zxing/BinaryBitmap.h>
#include <zxing/HybridBinarizer.h>
#include <zxing/BitMatrix.h>
#include <zxing/Result.h>

using namespace std;
using namespace cv;
using namespace zxing;

int main() {
    // Load the image containing the barcode
    string imagePath = "barcode.png";
    Mat image = imread(imagePath, IMREAD_GRAYSCALE);
    if (image.empty()) {
        cerr << "Error loading image." << endl;
        return 1;
    }

    // Convert Mat image to zxing::BitMatrix
    int width = image.cols;
    int height = image.rows;
    vector<uchar> imgData(image.data, image.data + (width * height));
    Ref<BitMatrix> bitMatrix = Ref<BitMatrix>(new BitMatrix(width, height));
    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            uchar pixel = imgData[y * width + x];
            bitMatrix->set(x, y, pixel < 128);
        }
    }

    // Create a BinaryBitmap from BitMatrix
    Ref<BinaryBitmap> binaryBitmap = Ref<BinaryBitmap>(new BinaryBitmap(Ref<HybridBinarizer>(new HybridBinarizer(bitMatrix))));

    // Create a reader and decode the barcode
    MultiFormatReader reader;
    DecodeHints hints;
    hints.setTryHarder(true);
    Ref<Result> result = reader.decode(binaryBitmap, hints);

    // Output the result
    if (result) {
        cout << "Barcode text: " << result->getText()->getText() << endl;
    } else {
        cout << "No barcode found." << endl;
    }

    return 0;
}

#include <iostream>

#include <opencv2/opencv.hpp>

#include <zxing/BarcodeFormat.h>

#include <zxing/DecodeHints.h>

#include <zxing/Reader.h>

#include <zxing/MultiFormatReader.h>

#include <zxing/BinaryBitmap.h>

#include <zxing/HybridBinarizer.h>

#include <zxing/BitMatrix.h>

#include <zxing/Result.h>

using namespace std;

using namespace cv;

using namespace zxing;

int main() {

// Load the image containing the barcode

string imagePath = "barcode.png";

Mat image = imread(imagePath, IMREAD_GRAYSCALE);

if (image.empty()) {

cerr << "Error loading image." << endl;

return 1;

}

// Convert Mat image to zxing::BitMatrix

int width = image.cols;

int height = image.rows;

vector<uchar> imgData(image.data, image.data + (width * height));

Ref<BitMatrix> bitMatrix = Ref<BitMatrix>(new BitMatrix(width, height));

for (int y = 0; y < height; ++y) {

for (int x = 0; x < width; ++x) {

uchar pixel = imgData[y * width + x];

bitMatrix->set(x, y, pixel < 128);

}

// Create a BinaryBitmap from BitMatrix

Ref<BinaryBitmap> binaryBitmap = Ref<BinaryBitmap>(new BinaryBitmap(Ref<HybridBinarizer>(new HybridBinarizer(bitMatrix))));

// Create a reader and decode the barcode

MultiFormatReader reader;

DecodeHints hints;

hints.setTryHarder(true);

Ref<Result> result = reader.decode(binaryBitmap, hints);

// Output the result

if (result) {

cout << "Barcode text: " << result->getText()->getText() << endl;

} else {

cout << "No barcode found." << endl;

}

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <opencv2/opencv.hpp>: For image processing using OpenCV. ZXing headers for barcode processing. Load the Image: Mat image = imread(imagePath, IMREAD_GRAYSCALE);: Load the image in grayscale mode using OpenCV. Convert OpenCV Image to ZXing BitMatrix: Extract pixel data from the cv::Mat object and convert it …

Barcode Reader Gaming Project in C++ Read More »

Bank Management System Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>
#include <iomanip>

using namespace std;

class Account {
private:
    int accountNumber;
    string accountHolder;
    double balance;
    vector<string> transactionHistory;

public:
    Account(int accNum, string accHolder, double initialBalance)
        : accountNumber(accNum), accountHolder(accHolder), balance(initialBalance) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            transactionHistory.push_back("Deposited $" + to_string(amount));
        } else {
            cout << "Invalid deposit amount." << endl;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            transactionHistory.push_back("Withdrew $" + to_string(amount));
        } else {
            cout << "Insufficient funds or invalid amount." << endl;
        }
    }

    void checkBalance() const {
        cout << fixed << setprecision(2);
        cout << "Balance: $" << balance << endl;
    }

    void showTransactionHistory() const {
        cout << "Transaction History:" << endl;
        for (const auto& transaction : transactionHistory) {
            cout << transaction << endl;
        }
    }

    int getAccountNumber() const {
        return accountNumber;
    }
};

class Bank {
private:
    vector<Account> accounts;

public:
    void createAccount(int accNum, string accHolder, double initialBalance) {
        accounts.emplace_back(accNum, accHolder, initialBalance);
        cout << "Account created successfully!" << endl;
    }

    Account* findAccount(int accNum) {
        for (auto& account : accounts) {
            if (account.getAccountNumber() == accNum) {
                return &account;
            }
        }
        return nullptr;
    }

    void deposit(int accNum, double amount) {
        Account* account = findAccount(accNum);
        if (account) {
            account->deposit(amount);
        } else {
            cout << "Account not found." << endl;
        }
    }

    void withdraw(int accNum, double amount) {
        Account* account = findAccount(accNum);
        if (account) {
            account->withdraw(amount);
        } else {
            cout << "Account not found." << endl;
        }
    }

    void checkBalance(int accNum) const {
        const Account* account = findAccount(accNum);
        if (account) {
            account->checkBalance();
        } else {
            cout << "Account not found." << endl;
        }
    }

    void showTransactionHistory(int accNum) const {
        const Account* account = findAccount(accNum);
        if (account) {
            account->showTransactionHistory();
        } else {
            cout << "Account not found." << endl;
        }
    }
};

int main() {
    Bank bank;
    int choice, accNum;
    string accHolder;
    double amount;

    do {
        cout << "\nBank Management System" << endl;
        cout << "1. Create Account" << endl;
        cout << "2. Deposit Money" << endl;
        cout << "3. Withdraw Money" << endl;
        cout << "4. Check Balance" << endl;
        cout << "5. View Transaction History" << endl;
        cout << "6. Exit" << endl;
        cout << "Enter your choice: ";
        cin >> choice;

        switch (choice) {
            case 1:
                cout << "Enter account number: ";
                cin >> accNum;
                cout << "Enter account holder name: ";
                cin.ignore();  // Ignore leftover newline character
                getline(cin, accHolder);
                cout << "Enter initial balance: $";
                cin >> amount;
                bank.createAccount(accNum, accHolder, amount);
                break;
            case 2:
                cout << "Enter account number: ";
                cin >> accNum;
                cout << "Enter amount to deposit: $";
                cin >> amount;
                bank.deposit(accNum, amount);
                break;
            case 3:
                cout << "Enter account number: ";
                cin >> accNum;
                cout << "Enter amount to withdraw: $";
                cin >> amount;
                bank.withdraw(accNum, amount);
                break;
            case 4:
                cout << "Enter account number: ";
                cin >> accNum;
                bank.checkBalance(accNum);
                break;
            case 5:
                cout << "Enter account number: ";
                cin >> accNum;
                bank.showTransactionHistory(accNum);
                break;
            case 6:
                cout << "Exiting the system. Goodbye!" << endl;
                break;
            default:
                cout << "Invalid choice. Please select a valid option." << endl;
                break;
        }
    } while (choice != 6);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

#include <iostream>

#include <vector>

#include <string>

#include <iomanip>

using namespace std;

class Account {

private:

int accountNumber;

string accountHolder;

double balance;

vector<string> transactionHistory;

public:

Account(int accNum, string accHolder, double initialBalance)

: accountNumber(accNum), accountHolder(accHolder), balance(initialBalance) {}

void deposit(double amount) {

if (amount > 0) {

balance += amount;

transactionHistory.push_back("Deposited $" + to_string(amount));

} else {

cout << "Invalid deposit amount." << endl;

}

void withdraw(double amount) {

if (amount > 0 && amount <= balance) {

balance -= amount;

transactionHistory.push_back("Withdrew $" + to_string(amount));

} else {

cout << "Insufficient funds or invalid amount." << endl;

}

void checkBalance() const {

cout << fixed << setprecision(2);

cout << "Balance: $" << balance << endl;

}

void showTransactionHistory() const {

cout << "Transaction History:" << endl;

for (const auto& transaction : transactionHistory) {

cout << transaction << endl;

}

int getAccountNumber() const {

return accountNumber;

}

};

class Bank {

private:

vector<Account> accounts;

public:

void createAccount(int accNum, string accHolder, double initialBalance) {

accounts.emplace_back(accNum, accHolder, initialBalance);

cout << "Account created successfully!" << endl;

}

Account* findAccount(int accNum) {

for (auto& account : accounts) {

if (account.getAccountNumber() == accNum) {

return &account;

}

return nullptr;

}

void deposit(int accNum, double amount) {

Account* account = findAccount(accNum);

if (account) {

account->deposit(amount);

} else {

cout << "Account not found." << endl;

}

void withdraw(int accNum, double amount) {

Account* account = findAccount(accNum);

if (account) {

account->withdraw(amount);

} else {

cout << "Account not found." << endl;

}

void checkBalance(int accNum) const {

const Account* account = findAccount(accNum);

if (account) {

account->checkBalance();

} else {

cout << "Account not found." << endl;

}

void showTransactionHistory(int accNum) const {

const Account* account = findAccount(accNum);

if (account) {

account->showTransactionHistory();

} else {

cout << "Account not found." << endl;

}

};

int main() {

Bank bank;

int choice, accNum;

string accHolder;

double amount;

do {

cout << "\nBank Management System" << endl;

cout << "1. Create Account" << endl;

cout << "2. Deposit Money" << endl;

cout << "3. Withdraw Money" << endl;

cout << "4. Check Balance" << endl;

cout << "5. View Transaction History" << endl;

cout << "6. Exit" << endl;

cout << "Enter your choice: ";

cin >> choice;

switch (choice) {

case 1:

cout << "Enter account number: ";

cin >> accNum;

cout << "Enter account holder name: ";

cin.ignore(); // Ignore leftover newline character

getline(cin, accHolder);

cout << "Enter initial balance: $";

cin >> amount;

bank.createAccount(accNum, accHolder, amount);

break;

case 2:

cout << "Enter account number: ";

cin >> accNum;

cout << "Enter amount to deposit: $";

cin >> amount;

bank.deposit(accNum, amount);

break;

case 3:

cout << "Enter account number: ";

cin >> accNum;

cout << "Enter amount to withdraw: $";

cin >> amount;

bank.withdraw(accNum, amount);

break;

case 4:

cout << "Enter account number: ";

cin >> accNum;

bank.checkBalance(accNum);

break;

case 5:

cout << "Enter account number: ";

cin >> accNum;

bank.showTransactionHistory(accNum);

break;

case 6:

cout << "Exiting the system. Goodbye!" << endl;

break;

default:

cout << "Invalid choice. Please select a valid option." << endl;

break;

}

} while (choice != 6);

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <vector>: For using vectors to manage multiple accounts and transactions. #include <string>: For string operations. #include <iomanip>: For formatting output (e.g., setting decimal precision). Account Class: Private Data Members: accountNumber: Unique identifier for the account. accountHolder: Name of the account holder. balance: Current …

Bank Management System Gaming Project in C++ Read More »

Audio Steganography Gaming Project in C++

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

#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>

// Function to embed a message into WAV audio data
void embedMessage(const std::string& inputWav, const std::string& outputWav, const std::string& message) {
    std::ifstream inFile(inputWav, std::ios::binary);
    if (!inFile) {
        std::cerr << "Error opening input WAV file." << std::endl;
        return;
    }

    std::ofstream outFile(outputWav, std::ios::binary);
    if (!outFile) {
        std::cerr << "Error opening output WAV file." << std::endl;
        return;
    }

    // Read WAV header
    std::vector<char> header(44);
    inFile.read(header.data(), 44);
    outFile.write(header.data(), 44);

    // Prepare the message for embedding
    std::string messageWithTerminator = message + '\0';  // Null-terminate the message
    std::vector<char> messageBits(messageWithTerminator.begin(), messageWithTerminator.end());

    // Read audio data
    std::vector<char> audioData((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());
    inFile.close();

    // Ensure the message fits into the audio data
    if (messageBits.size() * 8 > audioData.size()) {
        std::cerr << "Message is too long to embed in the audio file." << std::endl;
        return;
    }

    // Embed the message bits into the audio data
    for (size_t i = 0; i < messageBits.size() * 8; ++i) {
        char& audioByte = audioData[i];
        char messageBit = (messageBits[i / 8] >> (i % 8)) & 1;
        audioByte = (audioByte & ~1) | messageBit;  // Modify the least significant bit
    }

    // Write the modified audio data to the output file
    outFile.write(audioData.data(), audioData.size());
    outFile.close();
}

// Function to extract a message from WAV audio data
std::string extractMessage(const std::string& inputWav, size_t messageLength) {
    std::ifstream inFile(inputWav, std::ios::binary);
    if (!inFile) {
        std::cerr << "Error opening input WAV file." << std::endl;
        return "";
    }

    // Skip WAV header
    inFile.seekg(44);

    // Read audio data
    std::vector<char> audioData((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());
    inFile.close();

    std::vector<char> messageBits(messageLength);
    for (size_t i = 0; i < messageLength * 8; ++i) {
        char& audioByte = audioData[i];
        char messageBit = audioByte & 1;
        messageBits[i / 8] |= (messageBit << (i % 8));  // Extract the LSB
    }

    return std::string(messageBits.begin(), messageBits.end());
}

int main() {
    std::string inputWav = "input.wav";
    std::string outputWav = "output.wav";
    std::string message = "Hidden Message";

    embedMessage(inputWav, outputWav, message);
    std::cout << "Message embedded into audio file." << std::endl;

    std::string extractedMessage = extractMessage(outputWav, message.size() + 1);
    std::cout << "Extracted Message: " << extractedMessage << std::endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

#include <cstring>

// Function to embed a message into WAV audio data

void embedMessage(const std::string& inputWav, const std::string& outputWav, const std::string& message) {

std::ifstream inFile(inputWav, std::ios::binary);

if (!inFile) {

std::cerr << "Error opening input WAV file." << std::endl;

return;

}

std::ofstream outFile(outputWav, std::ios::binary);

if (!outFile) {

std::cerr << "Error opening output WAV file." << std::endl;

return;

}

// Read WAV header

std::vector<char> header(44);

inFile.read(header.data(), 44);

outFile.write(header.data(), 44);

// Prepare the message for embedding

std::string messageWithTerminator = message + '\0'; // Null-terminate the message

std::vector<char> messageBits(messageWithTerminator.begin(), messageWithTerminator.end());

// Read audio data

std::vector<char> audioData((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());

inFile.close();

// Ensure the message fits into the audio data

if (messageBits.size() * 8 > audioData.size()) {

std::cerr << "Message is too long to embed in the audio file." << std::endl;

return;

}

// Embed the message bits into the audio data

for (size_t i = 0; i < messageBits.size() * 8; ++i) {

char& audioByte = audioData[i];

char messageBit = (messageBits[i / 8] >> (i % 8)) & 1;

audioByte = (audioByte & ~1) | messageBit; // Modify the least significant bit

}

// Write the modified audio data to the output file

outFile.write(audioData.data(), audioData.size());

outFile.close();

}

// Function to extract a message from WAV audio data

std::string extractMessage(const std::string& inputWav, size_t messageLength) {

std::ifstream inFile(inputWav, std::ios::binary);

if (!inFile) {

std::cerr << "Error opening input WAV file." << std::endl;

return "";

}

// Skip WAV header

inFile.seekg(44);

// Read audio data

std::vector<char> audioData((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());

inFile.close();

std::vector<char> messageBits(messageLength);

for (size_t i = 0; i < messageLength * 8; ++i) {

char& audioByte = audioData[i];

char messageBit = audioByte & 1;

messageBits[i / 8] |= (messageBit << (i % 8)); // Extract the LSB

}

return std::string(messageBits.begin(), messageBits.end());

}

int main() {

std::string inputWav = "input.wav";

std::string outputWav = "output.wav";

std::string message = "Hidden Message";

embedMessage(inputWav, outputWav, message);

std::cout << "Message embedded into audio file." << std::endl;

std::string extractedMessage = extractMessage(outputWav, message.size() + 1);

std::cout << "Extracted Message: " << extractedMessage << std::endl;

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <fstream>: For file handling. #include <vector>: For using vectors to manage data. #include <cstring>: For C-string manipulation functions (though not used in this example). Embed Message Function (embedMessage): Opens the input WAV file for reading and the output WAV file for writing. Reads …

Audio Steganography Gaming Project in C++ Read More »

Audio Processing Basics Gaming Project in C++

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

#include <iostream>
#include <SDL2/SDL.h>

// Audio callback function to handle audio playback
void audioCallback(void* userdata, Uint8* stream, int len) {
    SDL_memset(stream, 0, len);  // Clear the audio buffer

    // Cast userdata to SDL_AudioSpec pointer
    SDL_AudioSpec* spec = (SDL_AudioSpec*)userdata;

    // Check if audio data is available
    if (spec->userdata) {
        Uint8* audioData = (Uint8*)spec->userdata;
        SDL_memcpy(stream, audioData, len);  // Copy audio data to the stream
        spec->userdata = NULL;  // Clear the userdata to stop playback
    }
}

int main(int argc, char* argv[]) {
    if (SDL_Init(SDL_INIT_AUDIO) < 0) {  // Initialize SDL audio subsystem
        std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    // Load WAV file
    SDL_AudioSpec wavSpec;
    Uint8* wavStart;
    Uint32 wavLength;
    if (SDL_LoadWAV("example.wav", &wavSpec, &wavStart, &wavLength) == NULL) {
        std::cerr << "Failed to load WAV file! SDL_Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    // Set up audio specifications and callback
    wavSpec.callback = audioCallback;
    wavSpec.userdata = wavStart;  // Set userdata to the loaded WAV data

    // Open audio device
    if (SDL_OpenAudio(&wavSpec, NULL) < 0) {
        std::cerr << "Failed to open audio device! SDL_Error: " << SDL_GetError() << std::endl;
        SDL_FreeWAV(wavStart);
        SDL_Quit();
        return 1;
    }

    SDL_PauseAudio(0);  // Start audio playback

    // Wait for audio to finish playing
    SDL_Delay(3000);  // Wait for 3 seconds (adjust as needed for your audio length)

    SDL_CloseAudio();  // Close audio device
    SDL_FreeWAV(wavStart);  // Free the loaded WAV data
    SDL_Quit();  // Clean up SDL

    return 0;
}

#include <iostream>

#include <SDL2/SDL.h>

// Audio callback function to handle audio playback

void audioCallback(void* userdata, Uint8* stream, int len) {

SDL_memset(stream, 0, len); // Clear the audio buffer

// Cast userdata to SDL_AudioSpec pointer

SDL_AudioSpec* spec = (SDL_AudioSpec*)userdata;

// Check if audio data is available

if (spec->userdata) {

Uint8* audioData = (Uint8*)spec->userdata;

SDL_memcpy(stream, audioData, len); // Copy audio data to the stream

spec->userdata = NULL; // Clear the userdata to stop playback

}

int main(int argc, char* argv[]) {

if (SDL_Init(SDL_INIT_AUDIO) < 0) { // Initialize SDL audio subsystem

std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl;

return 1;

}

// Load WAV file

SDL_AudioSpec wavSpec;

Uint8* wavStart;

Uint32 wavLength;

if (SDL_LoadWAV("example.wav", &wavSpec, &wavStart, &wavLength) == NULL) {

std::cerr << "Failed to load WAV file! SDL_Error: " << SDL_GetError() << std::endl;

SDL_Quit();

return 1;

}

// Set up audio specifications and callback

wavSpec.callback = audioCallback;

wavSpec.userdata = wavStart; // Set userdata to the loaded WAV data

// Open audio device

if (SDL_OpenAudio(&wavSpec, NULL) < 0) {

std::cerr << "Failed to open audio device! SDL_Error: " << SDL_GetError() << std::endl;

SDL_FreeWAV(wavStart);

SDL_Quit();

return 1;

}

SDL_PauseAudio(0); // Start audio playback

// Wait for audio to finish playing

SDL_Delay(3000); // Wait for 3 seconds (adjust as needed for your audio length)

SDL_CloseAudio(); // Close audio device

SDL_FreeWAV(wavStart); // Free the loaded WAV data

SDL_Quit(); // Clean up SDL

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <SDL2/SDL.h>: For SDL functions and types. Audio Callback Function (audioCallback): This function is called by SDL when audio needs to be played. It clears the audio buffer with SDL_memset. Copies audio data from userdata to the stream buffer. Sets userdata to NULL after …

Audio Processing Basics Gaming Project in C++ Read More »

ATM Machine Simulation Gaming Project in C++

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

#include <iostream>
#include <iomanip>  // For std::setw and std::setprecision

using namespace std;

// Function prototypes
void displayMenu();
void checkBalance(double balance);
void deposit(double &balance);
void withdraw(double &balance);

int main() {
    double balance = 0.0;  // Initial balance
    int choice;

    do {
        displayMenu();
        cin >> choice;

        switch (choice) {
            case 1:
                checkBalance(balance);
                break;
            case 2:
                deposit(balance);
                break;
            case 3:
                withdraw(balance);
                break;
            case 4:
                cout << "Exiting the ATM. Have a great day!" << endl;
                break;
            default:
                cout << "Invalid choice. Please select a valid option." << endl;
                break;
        }
    } while (choice != 4);

    return 0;
}

// Function to display the ATM menu
void displayMenu() {
    cout << "\nATM Menu" << endl;
    cout << "1. Check Balance" << endl;
    cout << "2. Deposit Money" << endl;
    cout << "3. Withdraw Money" << endl;
    cout << "4. Exit" << endl;
    cout << "Enter your choice: ";
}

// Function to check and display the current balance
void checkBalance(double balance) {
    cout << fixed << setprecision(2);  // Set precision for displaying currency
    cout << "Current Balance: $" << balance << endl;
}

// Function to deposit money into the account
void deposit(double &balance) {
    double amount;
    cout << "Enter amount to deposit: $";
    cin >> amount;

    if (amount > 0) {
        balance += amount;
        cout << "Deposited $" << amount << ". New Balance: $" << balance << endl;
    } else {
        cout << "Invalid deposit amount. Please enter a positive value." << endl;
    }
}

// Function to withdraw money from the account
void withdraw(double &balance) {
    double amount;
    cout << "Enter amount to withdraw: $";
    cin >> amount;

    if (amount > 0 && amount <= balance) {
        balance -= amount;
        cout << "Withdrew $" << amount << ". New Balance: $" << balance << endl;
    } else if (amount > balance) {
        cout << "Insufficient funds. Withdrawal amount exceeds balance." << endl;
    } else {
        cout << "Invalid withdrawal amount. Please enter a positive value." << endl;
    }
}

#include <iostream>

#include <iomanip> // For std::setw and std::setprecision

using namespace std;

// Function prototypes

void displayMenu();

void checkBalance(double balance);

void deposit(double &balance);

void withdraw(double &balance);

int main() {

double balance = 0.0; // Initial balance

int choice;

do {

displayMenu();

cin >> choice;

switch (choice) {

case 1:

checkBalance(balance);

break;

case 2:

deposit(balance);

break;

case 3:

withdraw(balance);

break;

case 4:

cout << "Exiting the ATM. Have a great day!" << endl;

break;

default:

cout << "Invalid choice. Please select a valid option." << endl;

break;

}

} while (choice != 4);

return 0;

}

// Function to display the ATM menu

void displayMenu() {

cout << "\nATM Menu" << endl;

cout << "1. Check Balance" << endl;

cout << "2. Deposit Money" << endl;

cout << "3. Withdraw Money" << endl;

cout << "4. Exit" << endl;

cout << "Enter your choice: ";

}

// Function to check and display the current balance

void checkBalance(double balance) {

cout << fixed << setprecision(2); // Set precision for displaying currency

cout << "Current Balance: $" << balance << endl;

}

// Function to deposit money into the account

void deposit(double &balance) {

double amount;

cout << "Enter amount to deposit: $";

cin >> amount;

if (amount > 0) {

balance += amount;

cout << "Deposited $" << amount << ". New Balance: $" << balance << endl;

} else {

cout << "Invalid deposit amount. Please enter a positive value." << endl;

}

// Function to withdraw money from the account

void withdraw(double &balance) {

double amount;

cout << "Enter amount to withdraw: $";

cin >> amount;

if (amount > 0 && amount <= balance) {

balance -= amount;

cout << "Withdrew $" << amount << ". New Balance: $" << balance << endl;

} else if (amount > balance) {

cout << "Insufficient funds. Withdrawal amount exceeds balance." << endl;

} else {

cout << "Invalid withdrawal amount. Please enter a positive value." << endl;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <iomanip>: For formatting the output (e.g., setting decimal precision). Function Prototypes: void displayMenu();: Displays the ATM menu. void checkBalance(double balance);: Displays the current balance. void deposit(double &balance);: Allows depositing money and updates the balance. void withdraw(double &balance);: Allows withdrawing money and updates the …

ATM Machine Simulation Gaming Project in C++ Read More »