This is one of my first major applications programmed in Java.
For this application, I created a library that did configurable precision calculations using BigDecimal. In particular, the library implements the main mathematical functions by accepting BigDecimal type of numbers and the desired precision.
The final application displays a text box where you can enter the operations you want to calculate. You can also store functions and variables.
The user interface is rudimentary and has some bugs that make it a bit tedious to use the application. I plan to design a new version hoping that it will improve this shortcoming.
The application works internally by analyzing the operation entered by the user and storing it in memory in tree form. By doing so, you can store formulas since you can save the tree as a function of one or more variables. After the operation tree has been obtained, the result is re-evaluated, and after completion, the total result is displayed.
It is a new version of the multi-precision calculator.
Objectives:
- Improve the application's class structure..
- Ability to calculate derivative functions.
- Improve the user interface.
- Improve help.
The main motive of this new version is to implement an algebraic derivation.
The idea for this capability originated in high school when one of the teachers suggested that the class participate in the annual software contest by presenting an application that could derive.
At that time, we didn't make much progress on the project, but almost 30 years later, an application that can derive has finally arrived :-).
A comprehensive manual exists that explains how the application works.
New version of the multi-precision calculator.
Objectives:
- Add the new version of the consult during startup to have a count of how many people use the application.
- Dark mood option
A comprehensive manual exists that explains how the application works.
The small application lens effect was the by-product of a spring break with no plans.
At that time, I was finishing programming the first version of the encoder (File Encoder Application), and I needed something catchy for the About ...
The original idea is not mine, but I implemented it based on an effect I had seen in one of those iconic DOS demos.
I decided to encapsulate the effect within a Java Swing JPanel for my project.
Everything within the panel can be magnified using a magnifying glass positioned at your chosen coordinates.
It was especially challenging to ensure that refreshing the text components, especially when modifying the selected text's location, did not adversely affect the visual appearance.
When you create the LensJPanel, the content of the JPanel is applied to the element that will undergo the magnifying effect. You can specify the radius of the magnifying glass and whether it will magnify or diminish the content.
When you have the radius and determine whether the magnifying glass will enlarge or shrink the content, a two-dimensional square matrix is created with one element for each square pixel containing the magnifying glass.
The algorithm calculates the coordinates of the corresponding source pixel in the original image for each destination pixel to determine the color when applying the transformation.
The transformation involves a simple polar coordinate transformation, which is why a magnifying lens is utilized:
A pixel is calculated from a specific position of the lens frame and is used to determine the color when the transformation is applied. The pixel will also be within the lens frame. In addition, the radius from the center of the lens to the angle for a given pixel is calculated. The "origin" pixel for the pixel we are calculating will be at the same angle, but the radius will change. The radius spans from 0% to 100% for both the “target” and “source” pixels, with 100% representing the length of the lens radius. The source pixel is calculated for each target pixel by maintaining its angle and transforming the radius using a function with a monotonically increasing derivative. This transformation occurs in the interval between 0 and 1, where f(0) equals 0 and f(1) equals 1. Here, 0 represents 0% of the lens radius, and 1 represents 100% of the lens radius. This means that the radii will take their source pixel from a smaller radius, which will expand the lens circle. Outside the circle of the lens, the transformation will be the identity, meaning the source pixel will not change.
The explanation is a bit confusing, but if you are interested in learning more about the subject, feel free to contact me.
I hope someone will find it useful :-).
The application's new version features a circular graphic window with a movable lens that can be controlled by clicking and dragging with your mouse.
You can exit the application by pressing ESC.
A couple of problems are evident:
- It is impossible to frequently refresh the enlarged background since, to take a screenshot, you have to set the window as transparent, which causes an annoying flickering.
- The image is quite pixelated, especially in the central part of the magnifying glass.
The new version of the application addresses a transparency bug that occurred on Mac and Linux operating systems.
The latest version also addresses the pixelation issue found in previous versions.
This is accomplished by applying a Gaussian smoothing filter to the lens image, creating a blurring effect that reduces the pixelation caused by magnification.
The latest available subversion of this version works with both Java-8 and Java-11.
The development of this application stemmed from the necessity to encrypt files using a custom method.
The application enables easy file encryption, utilizing time-saving encryption/decryption methods that make brute-force attacks less difficult and is suitable for encrypting small files.
There is a comprehensive user manual that explains the operation details for both users and internal application use.
This application version was created in response to issues caused by the new JRE version, which affected the visual aspect of the original application v1.0. Version 1.1 was developed to address these problems.
The user manual has not changed with this version and remains the same as the previous version's user manual.
A couple of changes were made in this version:
- Fixed a bug in the custom pseudo-random generator used in previous versions.
- New encryption methods designed specifically for use with large files have been developed to enhance encryption speed and robustness.
A specific user manual of this version exists that explains all of the details.
There have been several changes in this version:
- New encryption method optimized for large files using multiple threads.
- New encryption method that splits encrypted files into volumes when there are file size limitations.
- Magnification factor adjusts the window display to accommodate different device pixel densities.
There is a specific user manual for this version that explains all of the details.
This version has been developed to fix a bug that occurred when interacting with a new Java-9 feature dealing with high pixel-density screens.
Maven support is also included.
There is a specific user manual for this version that explains all the details.
The goal of this version is to add the new version query to get feedback on how many people are using the application.
The dark mode option has also been added.
There is a specific user manual for this version that provides detailed explanations.
Esta es la primera versión de una pequeña aplicación en Java que permitía ayudar a sincronizar subtítulos aplicando un factor temporal a los ficheros de subtítulos de tipo (.srt).
The application automatically detects the character set of the subtitle file. It lets you choose a character set to generate the output file, or use the detected code during the reading.
A few items have been added in this version:
- Help window
- Support for Spanish and English.
- Support for (.saa) file types has been added in addition to the (.srt) files already supported in the previous version.
- Ability to apply a delay in milliseconds to subtitles has been added, in addition to the factor in the previous version.
This makes it possible to perfectly synchronize the video and subtitles by knowing the delay and factor values beforehand.
This command interface application, written in C++, enables the application of a time factor to audio files.
This operation means input and output audio files will have different lengths and sizes.
The process involves interpolating digital signals to create the transformation.
There is a detailed guide to operate the application and understand its internal mechanisms.
Application developed in Java that enables you to connect to Google Drive and access a spreadsheet.
After this, the application populates a JTable with the data and enables you to filter it.
There is a comprehensive manual in Spanish, which explains how to configure the application step by step.
The Chess PDF Browser is an application programmed in Java that allows you to browse chess books in PDF format.
It also enables working with game files in .pgn format.
View a chessboard where you can browse through different games.
Allows you to open PDF chess books and extract games to save in .pgn format.
Allows you to edit the variants of the games stored in memory, whether they are read from .pgn, extracted from a PDF, or created directly by moving the pieces on the board.
There is a comprehensive manual that details how the application works.
Several bugs have been fixed, and new features have been added in the latest version of the application:
- New experimental game extractor.
- Mark moves as novelties. (Novelty).
- Language support in Russian has been added.
There is a comprehensive guide that explains how the application works.
The user guides have been updated with the new version of the application.
There is a comprehensive guide that explains how the application works.
With the latest version of the application, numerous new features have been added:
- The experimental line item extractor has been replaced by a new extractor that now takes into account brackets and square brackets.
- The system now has the capability to extract game data, including player names and ELO rankings.
- The ability to view the moves in a game in algebraic notation.
- An OCR has been implemented to recognize board positions and add them to games that do not start from the standard starting position.
- Now you can play games against another person or an engine or play two engines against each other.
- Enhanced connectivity to UCI engines:
- Modify the engine settings, for example, by decreasing the level to play against a lower level than the maximum.
- Analysis of positions.
- Full game analysis.
- You can use an engine as a player in a game.
- Dark mode option
There is a comprehensive guide that explains how the application works.
The application's new version can now extract game moves from PDFs using figurine algebraic notation.
What's new in this version:
- The software allows for extracting games in figurine algebraic notation, notating the movements of the pieces.
- Enhanced board position recognition using optical character recognition (OCR).
- Some bugs have been fixed.
There is a comprehensive guide that explains how the application works.
You can see a video of the new feature Demo video
ChessPdfBrowser application plugin
Introducing a command interface application that enables you to extract games games from PDF chess books and save them in .pgn format.
The application accepts different parameters, allowing you to:
- Specify the input file name (PDF book)
- Set the output file name (.pgn file)
- Choose the language of the PDF games.
- Choose which pages to extract the games from
There are basic scripts for different environments that execute the Java call and pass the parameters to the application:
- .bat script for Windows
- .sh script for Unix environments
Update to the online version of ChessPdfBrowser
A bash script has been added to simplify processing all the PDFs in a directory.
Currently, the online version is unable to process PDFs in figurine algebraic notation, but it has been updated to include the new functionality of the application.
TextCrypt is a small Java application that allows you to encrypt and decrypt plain text.
The text is always encrypted and never saved unencrypted on the hard disk.
The application can create an encrypted file that is compatible with the Java File Encoder application by simply changing the file extension to the appropriate format.
This update addresses several bugs from the previous version.
This update addresses several bugs from the previous version.
This version includes several new features:
- Edit text and easily undo or redo changes.
- Copy and paste text.
- An option to search for and replace text, which can also be used for expressions.
- The ability to resize the application window.
- The application is now able to recognize website links and email addresses.
This version of the application aims to prevent a bug that resulted from interaction with a new Java-9 feature, which automatically handles high pixel density (dpi) screens.
Additionally, support for Maven has been added.
A new query version has been added in this application update.
Dark mode option has been added.
This text encryptor has additional desirable features:
- Encryption is performed using a chaotic pseudo-random generator with XOR and character reordering. This is a non-standard encryption method that I programmed myself. This means that if someone tries to decrypt a file through a brute force attack without the password, they would have to deal with the code.
- If the file size exceeds 16 KB, it becomes resistant to brute force attacks due to character reordering, making it take a long time to reject an incorrect password.
- To prevent the encrypted file from being corrupted, it is first saved in a temporary file and then renamed to the actual file name.
- A backup copy of the previous file is also saved when saving the text.
- The text is always encrypted on the hard disk.
- Search and replace window.
- Select the zoom level for the windows.
- Dark mode.
Instrumental music is a small application programmed in Java that allows you to listen to music from a microphone.
It also lets you process the captured input and determine the predominant note in real-time.
Test the application by whistling notes and then setting it to play the detected note in MIDI.
This application makes for simple entertainment.
The version of the platform libraries has been updated in this release:
- You can change the application's zoom level.
- A new version query to get the statistics on how many people use the application.
- Dark mode option
You can now also set the amplitude threshold for detecting a note.
This application version results from the extra free time I had due to the ban on entering bars and restaurants in Catalonia without a COVID certificate during Christmas in 2021.
The most notable new feature is changing the voice pitch from lower to higher using a slider.
- New classes that facilitate the creation of producers and consumers.
- New classes enable audio bites to be consumed and processed in the frequency domain by applying an STFT.
- Several improvements in the class structure and user interface.
- Compatibility with jdk-17
Demo video
This application allows you to create icons by resizing an input image to various standard Windows icon sizes:
- 16 x 16
- 32 x 32
- 64 x 64
- 128 x 128
It also allows you to resize the input image to a customizable size, which can be different from the previous sizes.
You have the option to transform a specific color into another color during the resizing process. For instance, this can be utilized to change the background color, which might be transparent, to white.
You can also utilize it to adjust the alpha component (transparency) of the remaining pixels.
New dark mode option
This application lets you open PDF books and view their images and text.
It is a simple example showcasing the capabilities of the pdfbox library.
New dark mode option
The application presents a three-dimensional Donut, allowing for rotations on both axes.
It is a simple example of what can be achieved with platform libraries.
Library capabilities
- Multi-language support
- Visual components zoom
- Dark mode option
- Automatic undo/redo for text components, with a context menu included
- Ready-to-use text search/replace window.
- Base components for auto-completion windows.
- Components repositioning after window resizing.
- Base classes for on-the-fly text formatting in JTextPanes.
- Enhanced JFileChooser
- basic functions of all kinds:
- precise image resizing
- image processing, translating image pixels with a direct color translation function.
- Classes to facilitate processing with XML files (without validation)
- ...
This application is a music player.
It works with .m3u playlists, which can be created by dragging and dropping music files from the file explorer.
- Supported formats:
- 5-band equalizer from 0 dB to -20 dB
- Graphic 5-band equalizer
- Random mode option.
- Continuous playback option.
- Ability to automatically stop playback at the end of the current song.
- Song browser
Demo video
The inspiration for this application originated a long time ago.
My fascination with coding began during my youth when I enjoyed watching demonstrations presented by various coding teams at competitions worldwide.
The effects showcased in these demonstrations were particularly impressive, especially considering the limited capabilities of computers at that time.
I recall being captivated by a demonstration from a Spanish group that showcased a morphing effect: During the demonstration, the components underwent a series of transformations, culminating in the final component being turned into an iguana (this tied into their group being called "Iguana").
It was an impressive effect.
I have been pondering how to recreate this effect over the years. Now, I am introducing this application as the solution I propose.
There is a user guide that explains in detail how the application works.
Demonstration video:
Video created with the application
I am now interested in integrating AI elements into my personal project after completing a master's degree in Artificial Intelligence.
This time, there will be a library to detect older faces.
With this new version, we have aimed to simplify the user's task by adding tools for creating grids more easily.
More specifically, it includes a library that detects faces in images using dlib-68 face landmarks, which provides 68 vertices for each detected face.
With this new information, the application now allows:
- insert the 68 detected vertices with a single click
- more accurately position the vertices on the new faces
This improvement allows you to create Morphing projects more efficiently.
For example, you can create an interesting effect using four photos in less than 20 minutes, whereas with the previous version, it could have taken you at least two hours.
There is an user guide de usuario that explains in detail how to use the application.
Demonstration video
Video created with the application
The application implements a fractal image compression algorithm described in an IEEE paper from my university days. It is based on Delaunay triangulation and block coding.
I collaborated with a university classmate to develop the initial version of this algorithm during an internship for the last course of Teleco Television (plan 64 of Barcelona).
The internet was still in its early stages, and any progress relied almost entirely on individual efforts and physical documents.
I remember that we developed a fairly good Delaunay triangulation and successfully implemented the split and merge approach. This involved calculating the most representative triangles and finding the optimal mappings during the coding process. However, despite three months of intensive development, we never completed the application.
Now, 25 years later, I present to you this new implementation of the algorithm, fully developed and completed in a record time of two weeks.
Obviously, something will be improved 25 years later. Additionally, this time with added function support to handle triangles, which I had already programmed for the Morphing effect application.
This time using a Delaunay triangulation library programmed by professionals.
It's evident that when you don't have to make the bricks yourself, the faster you can build the walls ...
Demonstration video
The application, also written in Java, was introduced during the presentation of the Artificial Intelligence Master's Thesis (2022/2023).
The PowerPoint template we received had an orange theme, reflecting VIU University's school colors.
It seems like a good idea to create images that match that color range. I propose creating a command-line application to copy images based on the color hue.
The "Apache Commons CLI" library is used to parse input parameters for the command line, providing a new capability.
The slf4j logback option is also a new feature.
The colorBall application was created as a form of entertainment between projects. It was developed after finishing version v1.1 of the Morphing Editor and before starting work on the new version of the chess application.
The software uses Painter to program the ImageJPanel. This allows you to paint over the displayed image. It also utilizes KeyColorImage, which lets you color pixels with a selected hue using JColorChooser.
In this way, the app overlays a ball of selectable size, subtly colored with the chosen hue, on top of the displayed image.
The JColorChooser has been integrated into the libraries through the application, making it available for all applications:
- Multi-precision
- Dark mode
- Remember the last colors selected
Demonstration video
Polynomial root calculators are a staple in the field of computer science careers.
I contribute my version of the solution to the problem.
It is not a very efficient solution since the computational complexity in the worst case is O(G^2), where G represents the polynomial degree
However, I think it gets the job done effectively
The algorithm is based on calculating the roots of a polynomial, assuming that the roots of its derivative function are known
Under this assumption, it is straightforward to calculate the roots because we can determine the range limit of the roots (See: Properties of the polynomial roots)
In this manner, we can determine the range of each potential root by using the derivative function roots, and we can compute the zeros by applying Bolzano's theorem.
But ... we need the function to calculate the roots of the derivative function!
No problem. We use recursion to compute the roots of a polynomial. The recursive function has a termination case for the scenario of a polynomial of degree zero (a constant), which we assume has no roots.
Since the derivative function has one degree less than the original polynomial, by using recursion, we can calculate the roots of a polynomial at zero degrees, making it a simple problem to solve
This way of proceeding may require precision in our calculations, but that is not a problem if we use the Java BigDecimal class.
Combined Java desktop (QR printing) and Android (QR reading) application
This is the result of copying and pasting information from the internet that explains the functionality of the Zxing library for QR code processing.
There is also a command line application where you can create QR images.
This application was born out of a desire to integrate advanced A.I. capabilities, such as:
- Real-time speech recognition
- Text-to-speech conversion
- Interaction with generative natural language A.I.
With it, you can converse with a generative A.I.: Llama3.
Speaking into the microphone (the voice recognition is not perfect, but it recognizes some parts)
Editing the text to send to the A.I., and sending it
Viewing the A.I.'s response in real-time and listening to it through the speaker
Demonstration video
The super pojo generator was born from the need to unify different versions of pojo models, in order to try to offer a common logic to all versions.
You can see more details about the application and the associated library in the superpojo-model project on github
