Database And Image Processing Using Python And Access
Database And Image Processing Using Python And Access Book in PDF, ePub and Kindle version is available to download in english. Read online anytime anywhere directly from your device. Click on the download button below to get a free pdf file of Database And Image Processing Using Python And Access book. This book definitely worth reading, it is an incredibly well-written.
Database and Image Processing Using Python and Access by Vivian Siahaan Pdf
The book details how programmers and database professionals can develop access-based Python applications that involves database and image processing. This book is a access database crash course which overs microsoft acces-based GUI programming using Python. In chapter one, you will learn to use several widgets in PyQt5: Display a welcome message; Use the Radio Button widget; Grouping radio buttons; Displays options in the form of a check box; and Display two groups of check boxes. In chapter two, you will learn to use the following topics: Using Signal / Slot Editor; Copy and place text from one Line Edit widget to another; Convert data types and make a simple calculator; Use the Spin Box widget; Use scrollbars and sliders; Using the Widget List; Select a number of list items from one Widget List and display them on another Widget List widget; Add items to the Widget List; Perform operations on the Widget List; Use the Combo Box widget; Displays data selected by the user from the Calendar Widget; Creating a hotel reservation application; and Display tabular data using Table Widgets. In chapter three, you will learn: How to create the initial three tables project in the School database: Teacher, Class, and Subject tables; How to create database configuration files; How to create a Python GUI for inserting and editing tables; How to create a Python GUI to join and query the three tables. In chapter four, you will learn how to: Create a main form to connect all forms; Create a project will add three more tables to the school database: Student, Parent, and Tuition tables; Create a Python GUI for inserting and editing tables; Create a Python GUI to join and query over the three tables. In chapter five, you will join the six classes, Teacher, TClass, Subject, Student, Parent, and Tuition and make queries over those tables. In chapter six, you will create dan configure database. In this chapter, you will create Suspect table in crime database. This table has eleven columns: suspect_id (primary key), suspect_name, birth_date, case_date, report_date, suspect_ status, arrest_date, mother_name, address, telephone, and photo. You will also create GUI to display, edit, insert, and delete for this table. In chapter seven, you will create a table with the name Feature_Extraction, which has eight columns: feature_id (primary key), suspect_id (foreign key), feature1, feature2, feature3, feature4, feature5, and feature6. The six fields (except keys) will have LONGBINARY data type. You will also create GUI to display, edit, insert, and delete for this table. In chapter eight, you will create two tables, Police and Investigator. The Police table has six columns: police_id (primary key), province, city, address, telephone, and photo. The Investigator table has eight columns: investigator_id (primary key), investigator_name, rank, birth_date, gender, address, telephone, and photo. You will also create GUI to display, edit, insert, and delete for both tables. In the last chapter, you will create two tables, Victim and Case_File. The Victim table has nine columns: victim_id (primary key), victim_name, crime_type, birth_date, crime_date, gender, address, telephone, and photo. The Case_File table has seven columns: case_file_id (primary key), suspect_id (foreign key), police_id (foreign key), investigator_id (foreign key), victim_id (foreign key), status, and description. You will create GUI to display, edit, insert, and delete for both tables as well.
Database and Image Processing Using SQL Server and Python by Vivian Siahaan Pdf
The book details how programmers and database professionals can develop SQL Server-based Python applications that involves database and image processing. This book is SQL Server-based python programming. Microsoft SQL Server is robust relational database management system used by so many organizations of various sizes including top fortune 100 companies. SQL Server is a relational database management system (RDBMS) developed and marketed by Microsoft. As a database server, the primary function of the SQL Server is to store and retrieve data used by other applications. Deliberately designed for various levels of programming skill, this book is suitable for students, engineers, and even researchers in various disciplines. There is no need for advanced programming experience, and school-level programming skills are needed. In the first chapter, you will learn to use several widgets in PyQt5: Display a welcome message; Use the Radio Button widget; Grouping radio buttons; Displays options in the form of a check box; and Display two groups of check boxes. In chapter two, you will learn to use the following topics: Using Signal / Slot Editor; Copy and place text from one Line Edit widget to another; Convert data types and make a simple calculator; Use the Spin Box widget; Use scrollbars and sliders; Using the Widget List; Select a number of list items from one Widget List and display them on another Widget List widget; Add items to the Widget List; Perform operations on the Widget List; Use the Combo Box widget; Displays data selected by the user from the Calendar Widget; Creating a hotel reservation application; and Display tabular data using Table Widgets. In chapter three, you will learn: How to create the initial three tables project in the School database: Teacher, Class, and Subject tables; How to create database configuration files; How to create a Python GUI for inserting and editing tables; How to create a Python GUI to join and query the three tables. In chapter four, you will learn how to: Create a main form to connect all forms; Create a project will add three more tables to the school database: Student, Parent, and Tuition tables; Create a Python GUI for inserting and editing tables; Create a Python GUI to join and query over the three tables. In chapter five, you will join the six classes, Teacher, TClass, Subject, Student, Parent, and Tuition and make queries over those tables. In chapter six, you will create dan configure database. In this chapter, you will create Suspect table in crime database. This table has eleven columns: suspect_id (primary key), suspect_name, birth_date, case_date, report_date, suspect_ status, arrest_date, mother_name, address, telephone, and photo. You will also create GUI to display, edit, insert, and delete for this table. In chapter seven, you will create a table with the name Feature_Extraction, which has eight columns: feature_id (primary key), suspect_id (foreign key), feature1, feature2, feature3, feature4, feature5, and feature6. The six fields (except keys) will have VARBINARY(MAX) data type. You will also create GUI to display, edit, insert, and delete for this table. In chapter eight, you will create two tables, Police and Investigator. The Police table has six columns: police_id (primary key), province, city, address, telephone, and photo. The Investigator table has eight columns: investigator_id (primary key), investigator_name, rank, birth_date, gender, address, telephone, and photo. You will also create GUI to display, edit, insert, and delete for both tables. In the last chapter, you will create two tables, Victim and Case_File. The Victim table has nine columns: victim_id (primary key), victim_name, crime_type, birth_date, crime_date, gender, address, telephone, and photo. The Case_File table has seven columns: case_file_id (primary key), suspect_id (foreign key), police_id (foreign key), investigator_id (foreign key), victim_id (foreign key), status, and description. You will create GUI to display, edit, insert, and delete for both tables as well.
START FROM SCRATCH DIGITAL IMAGE PROCESSING WITH TKINTER by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
"Start from Scratch: Digital Image Processing with Tkinter" is a beginner-friendly guide that delves into the basics of digital image processing using Python and Tkinter, a popular GUI library. The project is divided into distinct modules, each focusing on a specific aspect of image manipulation. The journey begins with an exploration of Image Color Space. Here, readers encounter the Main Form, which serves as the entry point to the application. It provides a user-friendly interface for loading images, selecting color spaces, and visualizing various color channels. The Fundamental Utilities play a crucial role by providing core functionalities like loading images, converting color spaces, and manipulating pixel data. The project also includes forms dedicated to displaying individual color channels and offering insights into the current color space through histograms. The Plotting Utilities module facilitates the creation of visual representations such as plots and graphs, enhancing the user's understanding of color spaces. Moving on, the Image Transformation section introduces readers to techniques like the Fast Fourier Transform (FFT). The Fast Fourier Transform Utilities module enables the implementation of FFT algorithms for converting images from spatial to frequency domains. A corresponding form allows users to view images in the frequency domain, with additional adjustments made to the plotting utilities for effective visualization. In the context of Discrete Cosine Transform (DCT), readers gain insights into algorithms and functions for transforming images. The Form for Discrete Cosine Transform aids in visualizing images in the DCT domain, while the plotting utilities are modified to accommodate these transformed images. The Discrete Sine Transform (DST) section introduces readers to DST algorithms and their role in image transformation. A dedicated form for visualizing images in the DST domain is provided, and the plotting utilities are further extended to handle these transformations effectively. Moving Average Smoothing is another critical aspect covered in the project. The Filter2D Utilities facilitate the application of moving average smoothing techniques. Additionally, metrics utilities enable the assessment of the smoothing process, with forms available for displaying both metrics and the smoothed images. Next, the project addresses Exponential Moving Average techniques, modifying the existing utilities to accommodate this specific approach. Similarly, forms for visualizing results and metrics are provided. Readers are then introduced to techniques like Median Filtering, Savitzky-Golay Filtering, and Wiener Filtering. The Filter2D Utilities are adapted to facilitate these filtering methods, and metrics utilities are employed to assess the effectiveness of each technique. Forms dedicated to each filtering method provide a platform for visualizing the results. The final section of the project explores techniques such as Total Variation Denoising, Non-Local Means Denoising, and PCA Denoising. The Filter2D Utilities are once again modified to support these denoising techniques. Metrics utilities are employed to evaluate the denoising process, and dedicated forms offer visualization capabilities. By breaking down the project into these modules, readers can systematically grasp the fundamentals of digital image processing, gradually building their skills from one concept to the next. Each section provides hands-on experience and practical knowledge, making it an ideal starting point for beginners in image processing.
Image Processing and Acquisition using Python by Ravishankar Chityala,Sridevi Pudipeddi Pdf
Image Processing and Acquisition using Python provides readers with a sound foundation in both image acquisition and image processing—one of the first books to integrate these topics together. By improving readers’ knowledge of image acquisition techniques and corresponding image processing, the book will help them perform experiments more effectively and cost efficiently as well as analyze and measure more accurately. Long recognized as one of the easiest languages for non-programmers to learn, Python is used in a variety of practical examples. A refresher for more experienced readers, the first part of the book presents an introduction to Python, Python modules, reading and writing images using Python, and an introduction to images. The second part discusses the basics of image processing, including pre/post processing using filters, segmentation, morphological operations, and measurements. The second part describes image acquisition using various modalities, such as x-ray, CT, MRI, light microscopy, and electron microscopy. These modalities encompass most of the common image acquisition methods currently used by researchers in academia and industry. Features Covers both the physical methods of obtaining images and the analytical processing methods required to understand the science behind the images. Contains many examples, detailed derivations, and working Python examples of the techniques. Offers practical tips on image acquisition and processing. Includes numerous exercises to test the reader’s skills in Python programming and image processing, with solutions to selected problems, example programs, and images available on the book’s web page. New to this edition Machine learning has become an indispensable part of image processing and computer vision, so in this new edition two new chapters are included: one on neural networks and the other on convolutional neural networks. A new chapter on affine transform and many new algorithms. Updated Python code aligned to the latest version of modules.
Hands-On Image Processing with Python by Sandipan Dey Pdf
Explore the mathematical computations and algorithms for image processing using popular Python tools and frameworks. Key FeaturesPractical coverage of every image processing task with popular Python librariesIncludes topics such as pseudo-coloring, noise smoothing, computing image descriptorsCovers popular machine learning and deep learning techniques for complex image processing tasksBook Description Image processing plays an important role in our daily lives with various applications such as in social media (face detection), medical imaging (X-ray, CT-scan), security (fingerprint recognition) to robotics & space. This book will touch the core of image processing, from concepts to code using Python. The book will start from the classical image processing techniques and explore the evolution of image processing algorithms up to the recent advances in image processing or computer vision with deep learning. We will learn how to use image processing libraries such as PIL, scikit-mage, and scipy ndimage in Python. This book will enable us to write code snippets in Python 3 and quickly implement complex image processing algorithms such as image enhancement, filtering, segmentation, object detection, and classification. We will be able to use machine learning models using the scikit-learn library and later explore deep CNN, such as VGG-19 with Keras, and we will also use an end-to-end deep learning model called YOLO for object detection. We will also cover a few advanced problems, such as image inpainting, gradient blending, variational denoising, seam carving, quilting, and morphing. By the end of this book, we will have learned to implement various algorithms for efficient image processing. What you will learnPerform basic data pre-processing tasks such as image denoising and spatial filtering in PythonImplement Fast Fourier Transform (FFT) and Frequency domain filters (e.g., Weiner) in PythonDo morphological image processing and segment images with different algorithmsLearn techniques to extract features from images and match imagesWrite Python code to implement supervised / unsupervised machine learning algorithms for image processingUse deep learning models for image classification, segmentation, object detection and style transferWho this book is for This book is for Computer Vision Engineers, and machine learning developers who are good with Python programming and want to explore details and complexities of image processing. No prior knowledge of the image processing techniques is expected.
The Python Programming Language by Bradley N. Miller,David L. Ranum Pdf
An excellent supplement to Computer Science Illuminated, as well as a superb primer, Computer Science: The Python Programming Language offers a clear introduction to this user-friendly language. This overview describes the fundamentals of the interactive Python environment, the structure of Python programs, how Python supports object-oriented programming, and much more. Beginning programmers will be relieved that this modern programming language is not only easy to learn but easy to use as well!
Python GUI For Signal and Image Processing by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
You will learn to create GUI applications using the Qt toolkit. The Qt toolkit, also popularly known as Qt, is a cross-platform application and UI framework developed by Trolltech, which is used to develop GUI applications. You will develop an existing GUI by adding several Line Edit widgets to read input, which are used to set the range and step of the graph (signal). Next, Now, you can use a widget for each graph. Add another Widget from Containers in gui_graphics.ui using Qt Designer. Then, Now, you can use two Widgets, each of which has two canvases. The two canvases has QVBoxLayout in each Widget. Finally, you will apply those Widgets to display the results of signal and image processing techniques.
LEARN FROM SCRATCH SIGNAL AND IMAGE PROCESSING WITH PYTHON GUI by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
In this book, you will learn how to use OpenCV, NumPy library and other libraries to perform signal processing, image processing, object detection, and feature extraction with Python GUI (PyQt). You will learn how to filter signals, detect edges and segments, and denoise images with PyQt. You will also learn how to detect objects (face, eye, and mouth) using Haar Cascades and how to detect features on images using Harris Corner Detection, Shi-Tomasi Corner Detector, Scale-Invariant Feature Transform (SIFT), and Features from Accelerated Segment Test (FAST). In Chapter 1, you will learn: Tutorial Steps To Create A Simple GUI Application, Tutorial Steps to Use Radio Button, Tutorial Steps to Group Radio Buttons, Tutorial Steps to Use CheckBox Widget, Tutorial Steps to Use Two CheckBox Groups, Tutorial Steps to Understand Signals and Slots, Tutorial Steps to Convert Data Types, Tutorial Steps to Use Spin Box Widget, Tutorial Steps to Use ScrollBar and Slider, Tutorial Steps to Use List Widget, Tutorial Steps to Select Multiple List Items in One List Widget and Display It in Another List Widget, Tutorial Steps to Insert Item into List Widget, Tutorial Steps to Use Operations on Widget List, Tutorial Steps to Use Combo Box, Tutorial Steps to Use Calendar Widget and Date Edit, and Tutorial Steps to Use Table Widget. In Chapter 2, you will learn: Tutorial Steps To Create A Simple Line Graph, Tutorial Steps To Create A Simple Line Graph in Python GUI, Tutorial Steps To Create A Simple Line Graph in Python GUI: Part 2, Tutorial Steps To Create Two or More Graphs in the Same Axis, Tutorial Steps To Create Two Axes in One Canvas, Tutorial Steps To Use Two Widgets, Tutorial Steps To Use Two Widgets, Each of Which Has Two Axes, Tutorial Steps To Use Axes With Certain Opacity Levels, Tutorial Steps To Choose Line Color From Combo Box, Tutorial Steps To Calculate Fast Fourier Transform, Tutorial Steps To Create GUI For FFT, Tutorial Steps To Create GUI For FFT With Some Other Input Signals, Tutorial Steps To Create GUI For Noisy Signal, Tutorial Steps To Create GUI For Noisy Signal Filtering, and Tutorial Steps To Create GUI For Wav Signal Filtering. In Chapter 3, you will learn: Tutorial Steps To Convert RGB Image Into Grayscale, Tutorial Steps To Convert RGB Image Into YUV Image, Tutorial Steps To Convert RGB Image Into HSV Image, Tutorial Steps To Filter Image, Tutorial Steps To Display Image Histogram, Tutorial Steps To Display Filtered Image Histogram, Tutorial Steps To Filter Image With CheckBoxes, Tutorial Steps To Implement Image Thresholding, and Tutorial Steps To Implement Adaptive Image Thresholding. In Chapter 4, you will learn: Tutorial Steps To Generate And Display Noisy Image, Tutorial Steps To Implement Edge Detection On Image, Tutorial Steps To Implement Image Segmentation Using Multiple Thresholding and K-Means Algorithm, and Tutorial Steps To Implement Image Denoising. In Chapter 5, you will learn: Tutorial Steps To Detect Face, Eye, and Mouth Using Haar Cascades, Tutorial Steps To Detect Face Using Haar Cascades with PyQt, Tutorial Steps To Detect Eye, and Mouth Using Haar Cascades with PyQt, and Tutorial Steps To Extract Detected Objects. In Chapter 6, you will learn: Tutorial Steps To Detect Image Features Using Harris Corner Detection, Tutorial Steps To Detect Image Features Using Shi-Tomasi Corner Detection, Tutorial Steps To Detect Features Using Scale-Invariant Feature Transform (SIFT), and Tutorial Steps To Detect Features Using Features from Accelerated Segment Test (FAST). You can download the XML files from https://viviansiahaan.blogspot.com/2023/06/learn-from-scratch-signal-and-image.html.
Image Analysis and Recognition by Aurélio Campilho,Fakhri Karray Pdf
This book constitutes the thoroughly refereed proceedings of the 13th International Conference on Image Analysis and Recognition, ICIAR 2016, held in Póvoa de Varzim, Portugal, in July 2016. The 79 revised full papers and 10 short papers presented were carefully reviewed and selected from 167 submissions. The papers are organized in the following topical sections: Advances in Data Analytics and Pattern Recognition with Applications, Image Enhancement and Restoration, Image Quality Assessment, Image Segmentation, Pattern Analysis and Recognition, Feature Extraction, Detection and Recognition, Matching, Motion and Tracking, 3D Computer Vision, RGB-D Camera Applications, Visual Perception in Robotics, Biometrics, Biomedical Imaging, Brain Imaging, Cardiovascular Image Analysis, Image Analysis in Ophthalmology, Document Analysis, Applications, and Obituaries. The chapter 'Morphological Separation of Clustered Nuclei in Histological Images' is published open access under a CC BY 4.0 license at link.springer.com.
DIGITAL VIDEO PROCESSING PROJECTS USING PYTHON AND TKINTER by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
The first project is a video player application with an additional feature to compute and display the MD5 hash of each frame in a video. The user interface is built using Tkinter, a Python GUI toolkit, providing buttons for opening a video file, playing, pausing, and stopping the video playback. Upon opening a video file, the application displays metadata such as filename, duration, resolution, FPS, and codec information in a table. The video can be navigated using a slider to seek to a specific time point. When the video is played, the application iterates through each frame, extracts it from the video clip, calculates its MD5 hash, and displays the frame along with its histogram and MD5 hash. The histogram represents the pixel intensity distribution of each color channel (red, green, blue) in the frame. The computed MD5 hash for each frame is displayed in a label below the video frame. Additionally, the frame hash along with its index is saved to a text file for further analysis or verification purposes. The class encapsulates the functionality of the application, providing methods for opening a video file, playing and controlling video playback, updating metadata, computing frame histogram, plotting histogram, calculating MD5 hash for each frame, and saving frame hashes to a file. The main function initializes the Tkinter root window, instantiates the class, and starts the Tkinter event loop to handle user interactions and update the GUI accordingly. The second project is a video player application with additional features for frame extraction and visualization of RGB histograms for each frame. Developed using Tkinter, a Python GUI toolkit, the application provides functionalities such as opening a video file, playing, pausing, and stopping video playback. The user interface includes buttons for controlling video playback, a combobox for selecting zoom scale, an entry for specifying a time point to jump to, and buttons for frame extraction and opening another instance of the application. Upon opening a video file, the application loads it using the imageio library and displays the frames in a canvas. Users can play, pause, and stop the video using dedicated buttons. The zoom scale can be adjusted, and the video can be navigated using scrollbar or time entry. Additionally, users can extract a specific frame by entering its frame number, which opens a new window displaying the extracted frame along with its RGB histograms and MD5 hash value. The class encapsulates the application's functionalities, including methods for opening a video file, playing/pausing/stopping video, updating zoom scale, displaying frames, handling mouse events for dragging and scrolling, jumping to a specified time, and extracting frames. The main function initializes the Tkinter root window and starts the application's event loop to handle user interactions and update the GUI accordingly. Users can also open multiple instances of the application simultaneously to work with different video files concurrently. The third project is a GUI application built with Tkinter for calculating hash values of video frames and displaying them in a listbox. The interface consists of different frames for video display and hash values, along with buttons for controlling video playback, calculating hashes, saving hash values to a file, and opening a new instance of the application. Users can open a video file using the "Open Video" button, after which they can play, pause, or stop the video using corresponding buttons. Upon opening a video file, the application reads frames from the video capture and displays them in the designated frame. Users can interact with the video using playback buttons to control the video's flow. Hash values for each frame are calculated using various hashing algorithms such as MD5, SHA-1, SHA-256, and others. These hash values are then displayed in the listbox, allowing users to view the hash values corresponding to each algorithm. Additionally, users can save the calculated hash values to a text file by clicking the "Save Hashes" button, providing a convenient way to store and analyze the hash data. Lastly, users can open multiple instances of the application simultaneously by clicking the "Open New Instance" button, facilitating concurrent processing of different video files. The fourth project is a GUI application developed using Tkinter for analyzing video frames through frame hashing and histogram visualization. The interface presents a canvas for displaying the video frames along with control buttons for video playback, frame extraction, and zoom control. Users can open a video file using the "Open Video" button, and the application provides functionality to play, pause, and stop the video playback. Additionally, users can jump to specific time points within the video using the time entry field and "Jump to Time" button. Upon extracting a frame, the application opens a new window displaying the selected frame along with its histogram and multiple hash values calculated using various algorithms such as MD5, SHA-1, SHA-256, and others. The histogram visualization presents the distribution of pixel values across the RGB channels, aiding in the analysis of color composition within the frame. The hash values are displayed in a listbox within the frame extraction window, providing users with comprehensive information about the frame's content and characteristics. Furthermore, users can open multiple instances of the application simultaneously, enabling concurrent analysis of different video files. The fifth project implements a video player application with edge detection capabilities using various algorithms. The application is designed using the Tkinter library for the graphical user interface (GUI). Upon execution, the user is presented with a window containing control buttons and panels for displaying the video and extracted frames. The main functionalities of the application include opening a video file, playing, pausing, and stopping the video playback. Additionally, users can jump to a specific time in the video, extract frames, and open another instance of the video player application. The video playback is displayed on a canvas, allowing for zooming in and out using a combobox to adjust the scale. One of the key features of this application is the ability to perform edge detection on frames extracted from the video. When a frame is extracted, the application displays the original frame alongside its edge detection result using various algorithms such as Canny, Sobel, Prewitt, Laplacian, Scharr, Roberts, FreiChen, Kirsch, Robinson, Gaussian, or no edge detection. Histogram plots for each RGB channel of the frame are also displayed, along with hash values computed using different hashing algorithms for integrity verification. The edge detection result and histogram plots are updated dynamically based on the selected edge detection algorithm. Overall, this application provides a convenient platform for visualizing video content and performing edge detection analysis on individual frames, making it useful for tasks such as video processing, computer vision, and image analysis. The sixth project is a Python application built using the Tkinter library for creating a graphical user interface (GUI) to play videos and apply various filtering techniques to individual frames. The application allows users to open video files in common formats such as MP4, AVI, and MKV. Once a video is opened, users can play, pause, stop, and jump to specific times within the video. The GUI consists of two main panels: one for displaying the video and another for control buttons. The video panel contains a canvas where the frames of the video are displayed. Users can zoom in or out on the video frames using a combobox, and they can also scroll horizontally through the video using a scrollbar. Control buttons such as play/pause, stop, extract frame, and open another video player are provided in the control panel. When a frame is extracted, the application opens a new window displaying the extracted frame along with options to apply various filtering methods. These methods include Gaussian blur, mean blur, median blur, bilateral filtering, non-local means denoising, anisotropic diffusion, total variation denoising, Wiener filter, adaptive thresholding, and wavelet transform. Users can select a filtering method from a dropdown menu, and the filtered result along with the histogram and hash values of the frame are displayed in real-time. The application also provides functionality to open another instance of the video player, allowing users to work with multiple videos simultaneously. Overall, this project provides a user-friendly interface for playing videos and applying filtering techniques to individual frames, making it useful for tasks such as video processing, analysis, and editing.
FRAME ANALYSIS AND PROCESSING IN DIGITAL VIDEO USING PYTHON AND TKINTER by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
The first project in chapter one which is Canny Edge Detector presented here is a graphical user interface (GUI) application built using Tkinter in Python. This application allows users to open video files (of formats like mp4, avi, or mkv) and view them along with their corresponding Canny edge detection frames. The application provides functionalities such as playing, pausing, stopping, navigating through frames, and jumping to specific times within the video. Upon opening the application, users are greeted with a clean interface comprising two main sections: the video display panel and the control panel. The video display panel consists of two canvas widgets, one for displaying the original video and another for displaying the Canny edge detection result. These canvases allow users to visualize the video and its corresponding edge detection in real-time. The control panel houses various buttons and widgets for controlling the video playback and interaction. Users can open video files using the "Open Video" button, select a zoom scale for viewing convenience, jump to specific times within the video, play/pause the video, stop the video, navigate through frames, and even open another instance of the application for simultaneous use. The core functionality lies in the methods responsible for displaying frames and performing Canny edge detection. The show_frame() method retrieves frames from the video, resizes them based on the selected zoom scale, and displays them on the original video canvas. Similarly, the show_canny_frame() method applies the Canny edge detection algorithm to the frames, enhances the edges using dilation, and displays the resulting edge detection frames on the corresponding canvas. The application also supports mouse interactions such as dragging to pan the video frames within the canvas and scrolling to navigate through frames. These interactions are facilitated by event handling methods like on_press(), on_drag(), and on_scroll(), ensuring smooth user experience and intuitive control over video playback and exploration. Overall, this project provides a user-friendly platform for visualizing video content and exploring Canny edge detection results, making it valuable for educational purposes, research, or practical applications involving image processing and computer vision. This second project in chapter one implements a graphical user interface (GUI) application for performing edge detection using the Prewitt operator on videos. The purpose of the code is to provide users with a tool to visualize videos, apply the Prewitt edge detection algorithm, and interactively control playback and visualization parameters. The third project in chapter one which is "Sobel Edge Detector" is implemented in Python using Tkinter and OpenCV serves as a graphical user interface (GUI) for viewing and analyzing videos with real-time Sobel edge detection capabilities. The "Frei-Chen Edge Detection" project as fourth project in chapter one is a graphical user interface (GUI) application built using Python and the Tkinter library. The application is designed to process and visualize video files by detecting edges using the Frei-Chen edge detection algorithm. The core functionality of the application lies in the implementation of the Frei-Chen edge detection algorithm. This algorithm involves convolving the video frames with predefined kernels to compute the gradient magnitude, which represents the strength of edges in the image. The resulting edge-detected frames are thresholded to convert grayscale values to binary values, enhancing the visibility of edges. The application also includes features for user interaction, such as mouse wheel scrolling to zoom in and out, click-and-drag functionality to pan across the video frames, and input fields for jumping to specific times within the video. Additionally, users have the option to open multiple instances of the application simultaneously to analyze different videos concurrently, providing flexibility and convenience in video processing tasks. Overall, the "Frei-Chen Edge Detection" project offers a user-friendly interface for edge detection in videos, empowering users to explore and analyze visual data effectively. The "KIRSCH EDGE DETECTOR" project as the fifth project in chapter one is a Python application built using Tkinter, OpenCV, and NumPy libraries for performing edge detection on video files. It handles the visualization of the edge-detected frames in real-time. It retrieves the current frame from the video, applies Gaussian blur for noise reduction, performs Kirsch edge detection, and applies thresholding to obtain the binary edge image. The processed frame is then displayed on the canvas alongside the original video. This "SCHARR EDGE DETECTOR" as the sixth project in chapter one is creating a graphical user interface (GUI) to visualize edge detection in videos using the Scharr algorithm. It allows users to open video files, play/pause video playback, navigate frame by frame, and apply Scharr edge detection in real-time. The GUI consists of multiple components organized into panels. The main panel displays the original video on the left side and the edge-detected video using the Scharr algorithm on the right side. Both panels utilize Tkinter Canvas widgets for efficient rendering and manipulation of video frames. Users can interact with the application using control buttons located in the control panel. These buttons include options to open a video file, adjust the zoom scale, jump to a specific time in the video, play/pause video playback, stop the video, navigate to the previous or next frame, and open another instance of the application for parallel video analysis. The core functionality of the application lies in the VideoScharr class, which encapsulates methods for video loading, playback control, frame processing, and edge detection using the Scharr algorithm. The apply_scharr method implements the Scharr edge detection algorithm, applying a pair of 3x3 convolution kernels to compute horizontal and vertical derivatives of the image and then combining them to calculate the edge magnitude. Overall, the "SCHARR EDGE DETECTOR" project provides users with an intuitive interface to explore edge detection techniques in videos using the Scharr algorithm. It combines the power of image processing libraries like OpenCV and the flexibility of Tkinter for creating interactive and responsive GUI applications in Python. The first project in chapter two is designed to provide a user-friendly interface for processing video frames using Gaussian filtering techniques. It encompasses various components and functionalities tailored towards efficient video analysis and processing. The GaussianFilter Class serves as the backbone of the application, managing GUI initialization and video processing functionalities. The GUI layout is constructed with Tkinter widgets, comprising two main panels for video display and control buttons. Key functionalities include opening video files, controlling playback, adjusting zoom levels, navigating frames, and interacting with video frames via mouse events. Additionally, users can process frames using OpenCV for Gaussian filtering to enhance video quality and reduce noise. Time navigation functionality allows users to jump to specific time points in the video. Moreover, the application supports multiple instances for simultaneous video analysis in independent windows. Overall, this project offers a comprehensive toolset for video analysis and processing, empowering users with an intuitive interface and diverse functionalities. The second project in chapter two presents a Tkinter application tailored for video frame filtering utilizing a mean filter. It offers comprehensive functionalities including opening, playing/pausing, and stopping video playback, alongside options to navigate to previous and next frames, jump to specified times, and adjust zoom scale. Displayed on separate canvases, the original and filtered video frames are showcased distinctly. Upon video file opening, the application utilizes imageio.get_reader() for video reading, while play_video() and play_filtered_video() methods handle frame display. Individual frame rendering is managed by show_frame() and show_mean_frame(), incorporating noise addition through the add_noise() method. Mouse wheel scrolling, canvas dragging, and scrollbar scrolling are facilitated through event handlers, enhancing user interaction. Supplementary functionalities include time navigation, frame navigation, and the ability to open multiple instances using open_another_player(). The main() function initializes the Tkinter application and executes the event loop for GUI display. The third project in chapter two aims to develop a user-friendly graphical interface application for filtering video frames with a median filter. Supporting various video formats like MP4, AVI, and MKV, users can seamlessly open, play, pause, stop, and navigate through video frames. The key feature lies in real-time application of the median filter to enhance frame quality by noise reduction. Upon video file opening, the original frames are displayed alongside filtered frames, with users empowered to control zoom levels and frame navigation. Leveraging libraries such as tkinter, imageio, PIL, and OpenCV, the application facilitates efficient video analysis and processing, catering to diverse domains like surveillance, medical imaging, and scientific research. The fourth project in chapter two exemplifies the utilization of a bilateral filter within a Tkinter-based graphical user interface (GUI) for real-time video frame filtering. The script showcases the application of bilateral filtering, renowned for its ability to smooth images while preserving edges, to enhance video frames. The GUI integrates two main components: canvas panels for displaying original and filtered frames, facilitating interactive viewing and manipulation. Upon video file opening, original frames are displayed on the left panel, while bilateral-filtered frames appear on the right. Adjustable parameters within the bilateral filter method enable fine-tuning for noise reduction and edge preservation based on specific video characteristics. Control functionalities for playback, frame navigation, zoom scaling, and time jumping enhance user interaction, providing flexibility in exploring diverse video filtering techniques. Overall, the script offers a practical demonstration of bilateral filtering in real-time video processing within a Tkinter GUI, enabling efficient exploration of filtering methodologies. The fifth project in chapter two integrates a video player application with non-local means denoising functionality, utilizing tkinter for GUI design, PIL for image processing, imageio for video file reading, and OpenCV for denoising. The GUI, set up by the NonLocalMeansDenoising class, includes controls for playback, zoom, time navigation, and frame browsing, alongside features like mouse wheel scrolling and dragging for user interaction. Video loading and display are managed through methods like open_video and play_video(), which iterate through frames, resize them, and add noise for display on the canvas. Non-local means denoising is applied using the apply_non_local_denoising() method, enhancing frames before display on the filter canvas via show_non_local_frame(). The GUI fosters user interaction, offering controls for playback, zoom, time navigation, and frame browsing, while also ensuring error handling for seamless operation during video loading, processing, and denoising. The sixth project in chapter two provides a platform for filtering video frames using anisotropic diffusion. Users can load various video formats and control playback (play, pause, stop) while adjusting zoom levels and jumping to specific timestamps. Original video frames are displayed alongside filtered versions achieved through anisotropic diffusion, aiming to denoise images while preserving critical edges and structures. Leveraging OpenCV and imageio for image processing and PIL for manipulation tasks, the application offers a user-friendly interface with intuitive control buttons and multi-video instance support, facilitating efficient analysis and enhancement of video content through anisotropic diffusion-based filtering. The seventh project in chapter two is built with Tkinter and OpenCV for filtering video frames using the Wiener filter. It offers a user-friendly interface for opening video files, controlling playback, adjusting zoom levels, and applying the Wiener filter for noise reduction. With separate panels for displaying original and filtered video frames, users can interact with the frames via zooming, scrolling, and dragging functionalities. The application handles video processing internally by adding random noise to frames and applying the Wiener filter, ensuring enhanced visual quality. Overall, it provides a convenient tool for visualizing and analyzing videos while showcasing the effectiveness of the Wiener filter in image processing tasks. The first project in chapter three showcases optical flow observation using the Lucas-Kanade method. Users can open video files, play, pause, and stop them, adjust zoom levels, and jump to specific frames. The interface comprises two panels for original video display and optical flow results. With functionalities like frame navigation, zoom adjustment, and time-based jumping, users can efficiently analyze optical flow patterns. The Lucas-Kanade algorithm computes optical flow between consecutive frames, visualized as arrows and points, allowing users to observe directional changes and flow strength. Mouse wheel scrolling facilitates zoom adjustments for detailed inspection or broader perspective viewing. Overall, the application provides intuitive navigation and robust optical flow analysis tools for effective video observation. The second project in chapter three is designed to visualize optical flow with Kalman filtering. It features controls for video file manipulation, frame navigation, zoom adjustment, and parameter specification. The application provides side-by-side canvases for displaying original video frames and optical flow results, allowing users to interact with the frames and explore flow patterns. Internally, it employs OpenCV and NumPy for optical flow computation using the Farneback method, enhancing stability and accuracy with Kalman filtering. Overall, it offers a user-friendly interface for analyzing video data, benefiting fields like computer vision and motion tracking. The third project in chapter three is for optical flow analysis in videos using Gaussian pyramid techniques. Users can open video files and visualize optical flow between consecutive frames. The interface presents two panels: one for original video frames and the other for computed optical flow. Users can adjust zoom levels and specify optical flow parameters. Control buttons enable common video playback actions, and multiple instances can be opened for simultaneous analysis. Internally, OpenCV, Tkinter, and imageio libraries are used for video processing, GUI development, and image manipulation, respectively. Optical flow computation relies on the Farneback method, with resulting vectors visualized on the frames to reveal motion patterns.
MOTION ANALYSIS AND OBJECT TRACKING USING PYTHON AND TKINTER by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
The first project in chapter one, gui_optical_flow_robust_local.py, showcases Dense Robust Local Optical Flow (RLOF) through a graphical user interface (GUI) built using the OpenCV library within a tkinter framework. The project's functionality and structure are comprehensively organized, starting with the importation of essential libraries such as tkinter for GUI, PIL for image processing, imageio for video file reading, and OpenCV (cv2) for optical flow computations. The VideoDenseRLOFOpticalFlow class encapsulates the application's core functionality, initializing the GUI window, managing user interactions, and processing video frames for optical flow calculation and visualization. The GUI creation involves setting up widgets to display videos and control buttons for functions like opening files, playback control, and frame navigation. Optical flow is calculated using the Farneback method, and the resulting flow is visually presented alongside the original video frame. Mouse interaction capabilities enable users to pan the video frame and zoom in using the mouse wheel. Additionally, frame navigation features facilitate moving forward or backward through the video sequence. Error handling mechanisms are in place to provide informative messages during video processing. Overall, this project offers a user-friendly interface for exploring dense optical flow in video sequences, with potential for further customization and extension in optical flow research and applications. The second project in chapter one implements a graphical user interface (GUI) application for analyzing optical flow in video files using the Kalman filter. The application is built using the Tkinter library for the GUI components and OpenCV for image processing tasks such as optical flow computation. Upon execution, the application opens a window titled "Optical Flow Analysis with Kalman Filter" and provides functionalities for loading and playing video files. Users can open a video file through the "Open Video" button, which prompts a file dialog for file selection. Once a video file is chosen, the application loads it and displays the first frame on a canvas. The GUI includes controls for adjusting parameters such as the zoom scale, step size for optical flow computation, and displacement (dx and dy) for visualizing flow vectors. Users can interactively navigate through the video frames using buttons like "Play/Pause," "Stop," "Previous Frame," and "Next Frame." Additionally, there's an option to jump to a specific time in the video. The core functionality of the application lies in the show_optical_flow method, where optical flow is calculated using the Farneback method from OpenCV. The calculated optical flow is then filtered using a Kalman filter to improve accuracy and smoothness. The Kalman filter predicts the position of flow vectors and corrects them based on the measured flow values, resulting in more stable and reliable optical flow visualization. Overall, this application provides a user-friendly interface for visualizing optical flow in video files while incorporating a Kalman filter to enhance the quality of the flow estimation. It serves as a practical tool for researchers and practitioners in computer vision and motion analysis fields. The third project in chapter one presents a GUI application for visualizing optical flow through Lucas-Kanade estimation on video data. Utilizing Tkinter for GUI elements and integrating OpenCV, NumPy, Pillow, and imageio for video processing and visualization, the application opens a window titled "Optical Flow Analysis with Lucas Kanade" upon execution. Users can interact with controls to load video files, manipulate playback, adjust visualization parameters, and navigate frames. The GUI comprises video display, control, and optical flow panels, with functionalities including video loading, playback control, frame display, Lucas-Kanade optical flow computation, and error handling for stability. The VideoLucasKanadeOpticalFlow class encapsulates the application logic, defining event handlers for user interactions and facilitating seamless video interaction until window closure. The fourth project in chapter one features a graphical user interface (GUI) for visualizing Gaussian pyramid optical flow on video files, employing Tkinter for GUI components and OpenCV for optical flow calculation. Upon execution, the application opens a window titled "Gaussian Pyramid Optical Flow," enabling users to interact with video files. Controls include options for opening videos, adjusting zoom scale, setting step size for optical flow computation, and navigating frames. The core functionality revolves around the show_optical_flow method, which computes Gaussian pyramid optical flow using the Farneback method from OpenCV. This method calculates optical flow vectors between consecutive frames, visualized via lines and circles on an empty mask image displayed alongside the original video frame, facilitating the observation of motion patterns within the video. The "Face Detection in Video Using Haar Cascade" project as first project in chapter two, is aimed at detecting faces in video streams through Haar Cascade, a machine learning-based approach for object detection. The application offers a Tkinter-based graphical user interface (GUI) featuring functionalities like opening video files, controlling playback, adjusting zoom levels, and navigating frames. Upon selecting a video file, OpenCV processes each frame using the Haar Cascade classifier to detect faces, which are then outlined with rectangles. Users can interactively play, pause, stop, and navigate through video frames, observing real-time face detection. This project serves as a simple yet effective tool for visualizing and analyzing face detection in videos, suitable for educational and practical purposes. The "Object Tracking with Lucas Kanade" project is the second project in chapter two aimed at tracking objects within video streams using the Lucas-Kanade optical flow algorithm. Built with Tkinter for the graphical user interface (GUI) and OpenCV for video processing, it offers comprehensive functionalities for efficient object tracking. The GUI setup includes buttons for opening video files, playback control, and bounding box selection around objects of interest on the video display canvas. Video loading supports various formats, and playback features enable seamless navigation through frames. The core functionality lies in object tracking using the Lucas-Kanade algorithm, where bounding box coordinates are continuously updated based on estimated motion. Real-time GUI updates display current frames, frame numbers, and tracked object bounding boxes, while error handling ensures smooth user interaction. Overall, this project provides a user-friendly interface for accurate and efficient object tracking in video streams, making it a valuable tool for various applications. The third project in chapter two offers real-time object tracking in video streams using the Lucas-Kanade algorithm with Gaussian Pyramid for robust optical flow estimation. Its Tkinter-based graphical user interface (GUI) enables users to interact with the video stream, visualize tracking processes, and control parameters effectively. Upon application launch, users access controls for video loading, zoom adjustment, playback control, frame navigation, and center coordinate display clearance. The core track_object method tracks specified objects within video frames using Lucas-Kanade optical flow with Gaussian Pyramid, continuously updating bounding box coordinates for smooth and accurate tracking. As the video plays, users observe real-time motion of the tracked object's bounding box, reflecting its movement in the scene. With efficient frame processing, display updates, and intuitive controls, the application ensures a seamless user experience, suitable for diverse object tracking tasks. The fourth project in chapter two implements object tracking through the CAMShift (Continuously Adaptive Mean Shift) algorithm within a Tkinter-based graphical user interface (GUI). CAMShift, an extension of the Mean Shift algorithm, is tailored for object tracking in computer vision applications. Upon running the script, a window titled "Object Tracking with CAMShift" emerges, housing various GUI components. Users can open a video file via the "Open Video" button, loading supported formats such as .mp4, .avi, or .mkv. Playback controls allow for video manipulation, including play, pause, stop, and frame navigation, complemented by a zoom adjustment feature. During playback, the current frame number is displayed, aiding progress tracking. The core functionality centers on object tracking, where users can draw a bounding box around the object of interest on the video canvas. The CAMShift algorithm then continuously tracks this object within the bounding box across subsequent frames, updating its position in real-time. Additionally, the GUI presents the center coordinates of the bounding box in a list box, enhancing tracking insights. In summary, this script furnishes a user-friendly platform for object tracking via the CAMShift algorithm, facilitating visualization and analysis of object movement within video files. The fifth project in chapter two implements object tracking utilizing the MeanShift algorithm within a Tkinter-based graphical user interface (GUI). The script organizes its functionalities into five components: GUI Setup, GUI Components, Video Playback and Object Tracking, Bounding Box Interaction, and Main Function and Execution. Firstly, the script initializes the GUI window and essential attributes, including video file details and tracking status. Secondly, it structures the GUI layout, incorporating panels for video display and control buttons. Thirdly, methods for video playback control and object tracking are provided, enabling functionalities like opening video files, playing/pausing, and navigating frames. The MeanShift algorithm tracks objects within bounding boxes interactively manipulated by users through click-and-drag interactions. Lastly, the main function initializes the GUI application and starts the Tkinter event loop, launching the MeanShift-based object tracking interface. Overall, the project offers an intuitive platform for video playback, object tracking, and interactive bounding box manipulation, supporting diverse computer vision applications such as object detection and surveillance. The sixth project in chapter two introduces a video processing application utilizing the Kalman Filter for precise object tracking. Implemented with Tkinter, the application offers a graphical user interface (GUI) enabling users to open video files, control playback, and navigate frames. Its core objective is to accurately track a specified object across video frames. Upon initialization, the GUI elements, including control buttons, a canvas for video display, and a list box for center coordinate representation, are set up. The Kalman Filter, initialized with appropriate matrices for prediction and correction, enhances tracking accuracy. Upon opening a video file, the application loads and displays the first frame, enabling users to manipulate playback and frame navigation. During playback, the Kalman Filter algorithm is employed for object tracking. The track_object method orchestrates this process, extracting the region of interest (ROI), calculating histograms, and applying Kalman Filter prediction and correction steps to estimate the object's position. Updated bounding box coordinates are displayed on the canvas, while center coordinates are added to the list box. Overall, this user-friendly application showcases the Kalman Filter's effectiveness in video object tracking, providing smoother and more accurate results compared to traditional methods like MeanShift.
This proceeding constitutes the thoroughly refereed proceedings of the 1st International Conference on Combinatorial and Optimization, ICCAP 2021, December 7-8, 2021. This event was organized by the group of Professors in Chennai. The Conference aims to provide the opportunities for informal conversations, have proven to be of great interest to other scientists and analysts employing these mathematical sciences in their professional work in business, industry, and government. The Conference continues to promote better understanding of the roles of modern applied mathematics, combinatorics, and computer science to acquaint the investigator in each of these areas with the various techniques and algorithms which are available to assist in his or her research. We selected 257 papers were carefully reviewed and selected from 741 submissions. The presentations covered multiple research fields like Computer Science, Artificial Intelligence, internet technology, smart health care etc., brought the discussion on how to shape optimization methods around human and social needs.
Image Processing Masterclass with Python by Sandipan Dey Pdf
Over 50 problems solved with classical algorithms + ML / DL models KEY FEATURESÊ _ Problem-driven approach to practice image processing.Ê _ Practical usage of popular Python libraries: Numpy, Scipy, scikit-image, PIL and SimpleITK. _ End-to-end demonstration of popular facial image processing challenges using MTCNN and MicrosoftÕs Cognitive Vision APIs. Ê DESCRIPTIONÊ This book starts with basic Image Processing and manipulation problems and demonstrates how to solve them with popular Python libraries and modules. It then concentrates on problems based on Geometric image transformations and problems to be solved with Image hashing.Ê Next, the book focuses on solving problems based on Sampling, Convolution, Discrete Fourier transform, Frequency domain filtering and image restoration with deconvolution. It also aims at solving Image enhancement problems using differentÊ algorithms such as spatial filters and create a super resolution image using SRGAN. Finally, it explores popular facial image processing problems and solves them with Machine learning and Deep learning models using popular python ML / DL libraries. WHAT YOU WILL LEARNÊÊ _ Develop strong grip on the fundamentals of Image Processing and Image Manipulation. _ Solve popular Image Processing problems using Machine Learning and Deep Learning models. _ Working knowledge on Python libraries including numpy, scipyÊ and scikit-image. _ Use popular Python Machine Learning packages such as scikit-learn, Keras and pytorch. _ Live implementation of Facial Image Processing techniques such as Face Detection / Recognition / Parsing dlib and MTCNN. WHO THIS BOOK IS FORÊÊÊ This book is designed specially for computer vision users, machine learning engineers, image processing experts who are looking for solving modern image processing/computer vision challenges. TABLE OF CONTENTS 1. Chapter 1: Basic Image & Video Processing 2. Chapter 2: More Image Transformation and Manipulation 3. Chapter 3: Sampling, Convolution and Discrete Fourier Transform 4. Chapter 4: Discrete Cosine / Wavelet Transform and Deconvolution 5. Chapter 5: Image Enhancement 6. Chapter 6: More Image Enhancement 7. Chapter 7: Facel Image Processing
DATA ANALYSIS PROJECTS WITH MYSQL, SQLITE, POSTGRESQL, AND SQL SERVER USING PYTHON GUI by Vivian Siahaan,Rismon Hasiholan Sianipar Pdf
PROJECT 1: FULL SOURCE CODE: POSTGRESQL AND DATA SCIENCE FOR PROGRAMMERS WITH PYTHON GUI This project uses the PostgreSQL version of MySQL-based Sakila sample database which is a fictitious database designed to represent a DVD rental store. The tables of the database include film, film_category, actor, film_actor, customer, rental, payment and inventory among others. You can download the database from https://dev.mysql.com/doc/sakila/en/. In this project, you will write Python script to create every table and insert rows of data into each of them. You will develop GUI with PyQt5 to each table in the database. You will also create GUI to plot case distribution of film release year, film rating, rental duration, and categorize film length; plot rating variable against rental_duration variable in stacked bar plots; plot length variable against rental_duration variable in stacked bar plots; read payment table; plot case distribution of Year, Day, Month, Week, and Quarter of payment; plot which year, month, week, days of week, and quarter have most payment amount; read film list by joining five tables: category, film_category, film_actor, film, and actor; plot case distribution of top 10 and bottom 10 actors; plot which film title have least and most sales; plot which actor have least and most sales; plot which film category have least and most sales; plot case distribution of top 10 and bottom 10 overdue costumers; plot which store have most sales; plot average payment amount by month with mean and EWM; and plot payment amount over June 2005. PROJECT 2: FULL SOURCE CODE: MYSQL FOR STUDENTS AND PROGRAMMERS WITH PYTHON GUI In this project, we provide you with a MySQL version of an Oracle sample database named OT which is based on a global fictitious company that sells computer hardware including storage, motherboard, RAM, video card, and CPU. The company maintains the product information such as name, description standard cost, list price, and product line. It also tracks the inventory information for all products including warehouses where products are available. Because the company operates globally, it has warehouses in various locations around the world. The company records all customer information including name, address, and website. Each customer has at least one contact person with detailed information including name, email, and phone. The company also places a credit limit on each customer to limit the amount that customer can owe. Whenever a customer issues a purchase order, a sales order is created in the database with the pending status. When the company ships the order, the order status becomes shipped. In case the customer cancels an order, the order status becomes canceled. In addition to the sales information, the employee data is recorded with some basic information such as name, email, phone, job title, manager, and hire date. In this project, you will write Python script to create every table and insert rows of data into each of them. You will develop GUI with PyQt5 to each table in the database. You will also create GUI to plot: case distribution of order date by year, quarter, month, week, and day; the distribution of amount by year, quarter, month, week, day, and hour; the distribution of bottom 10 sales by product, top 10 sales by product, bottom 10 sales by customer, top 10 sales by customer, bottom 10 sales by category, top 10 sales by category, bottom 10 sales by status, top 10 sales by status, bottom 10 sales by customer city, top 10 sales by customer city, bottom 10 sales by customer state, top 10 sales by customer state, average amount by month with mean and EWM, average amount by every month, amount feature over June 2016, amount feature over 2017, and amount payment in all years. PROJECT 3: ZERO TO MASTERY: THE COMPLETE GUIDE TO LEARNING SQLITE AND PYTHON GUI In this project, we provide you with the SQLite version of The Oracle Database Sample Schemas that provides a common platform for examples in each release of the Oracle Database. The sample database is also a good database for practicing with SQL, especially SQLite. The detailed description of the database can be found on: http://luna-ext.di.fc.ul.pt/oracle11g/server.112/e10831/diagrams.htm#insertedID0. The four schemas are a set of interlinked schemas. This set of schemas provides a layered approach to complexity: A simple schema Human Resources (HR) is useful for introducing basic topics. An extension to this schema supports Oracle Internet Directory demos; A second schema, Order Entry (OE), is useful for dealing with matters of intermediate complexity. Many data types are available in this schema, including non-scalar data types; The Online Catalog (OC) subschema is a collection of object-relational database objects built inside the OE schema; The Product Media (PM) schema is dedicated to multimedia data types; The Sales History (SH) schema is designed to allow for demos with large amounts of data. An extension to this schema provides support for advanced analytic processing. The HR schema consists of seven tables: regions, countries, locations, departments, employees, jobs, and job_histories. This book only implements HR schema, since the other schemas will be implemented in the next books. PROJECT 4: FULL SOURCE CODE: SQL SERVER FOR STUDENTS AND DATA SCIENTISTS WITH PYTHON GUI In this project, we provide you with the SQL SERVER version of SQLite sample database named chinook. The chinook sample database is a good database for practicing with SQL, especially PostgreSQL. The detailed description of the database can be found on: https://www.sqlitetutorial.net/sqlite-sample-database/. The sample database consists of 11 tables: The employee table stores employees data such as employee id, last name, first name, etc. It also has a field named ReportsTo to specify who reports to whom; customers table stores customers data; invoices & invoice_items tables: these two tables store invoice data. The invoice table stores invoice header data and the invoice_items table stores the invoice line items data; The artist table stores artists data. It is a simple table that contains only the artist id and name; The album table stores data about a list of tracks. Each album belongs to one artist. However, one artist may have multiple albums; The media_type table stores media types such as MPEG audio and AAC audio files; genre table stores music types such as rock, jazz, metal, etc; The track table stores the data of songs. Each track belongs to one album; playlist & playlist_track tables: The playlist table store data about playlists. Each playlist contains a list of tracks. Each track may belong to multiple playlists. The relationship between the playlist table and track table is many-to-many. The playlist_track table is used to reflect this relationship. In this project, you will write Python script to create every table and insert rows of data into each of them. You will develop GUI with PyQt5 to each table in the database. You will also create GUI to plot: case distribution of order date by year, quarter, month, week, and day; the distribution of amount by year, quarter, month, week, day, and hour; the bottom/top 10 sales by employee, the bottom/top 10 sales by customer, the bottom/top 10 sales by customer, the bottom/top 10 sales by artist, the bottom/top 10 sales by genre, the bottom/top 10 sales by play list, the bottom/top 10 sales by customer city, the bottom/top 10 sales by customer city, the bottom/top 10 sales by customer city, the payment amount by month with mean and EWM, the average payment amount by every month, and amount payment in all years.
