The Art of Breathing is a JavaFX application for the Buteyko breathing exercise. The application allows users to log in with their credentials and access the breathing exercise.

• Java Development Kit (JDK) 11 or higher
• JavaFX SDK (if using JDK 8)

1. Clone the repository:

   git clone https://github.com/iigastudio/The-Art-of-Breathing

• Open the project in your preferred Java IDE.
• Set up the project dependencies:
  • If you’re using JDK 11 or higher, make sure the JavaFX libraries are added to your project’s classpath.
  • If you’re using JDK 8, include the JavaFX SDK as a library.
• Build the project.
• Run the BreathingMain class to launch the application.

• Launch the application.
• On the login screen, enter your credentials.
• If the credentials are valid, you will be logged in and redirected to the breathing exercise screen.
• Use the “Next” button to navigate to the next image in the exercise.
• When you reach the end of the exercise, the system will display a message and reset the exercise.

This project is licensed under the MIT License.

The Buteyko breathing method is a breathing technique developed by Dr. Konstantin Buteyko in the 1950s. It focuses on reducing the amount of breathing to improve overall health and well-being. The method is based on the principle that many health conditions, such as asthma, anxiety, and high blood pressure, are caused or worsened by chronic hyperventilation, which is excessive and shallow breathing. By practicing Buteyko breathing exercises, individuals learn to regulate their breathing, slow down their breath rate, and increase carbon dioxide levels in the body. This can have numerous benefits, including better oxygenation of tissues, reduced symptoms of respiratory conditions, improved relaxation, and enhanced overall respiratory and cardiovascular function.

🙏

PyTorch reference implementation of
“End-to-end optimized image compression with competition of prior distributions”
by Benoit Brummer and Christophe De Vleeschouwer ( https://github.com/trougnouf/Manypriors )

Forked from PyTorch implementation of
“Variational image compression with a scale hyperprior”
by Jiaheng Liu ( https://github.com/liujiaheng/compression )

This code is experimental.

TODO torchac should be switched to the standalone release on https://github.com/fab-jul/torchac (which was not yet released at the time of writing this code)

pacaur -S python-tqdm python-pytorch-torchac python-configargparse python-yaml python-ptflops python-colorspacious python-pypng python-pytorch-piqa-git

TMPDIR=tmp pip3 install --user torch==1.7.0+cu92 torchvision==0.8.1+cu92 -f https://download.pytorch.org/whl/torch_stable.html
TMPDIR=tmp pip3 install --user tqdm matplotlib tensorboardX scipy scikit-image scikit-video ConfigArgParse pyyaml h5py ptflops colorspacious pypng piqa

torchac must be compiled and installed per https://github.com/trougnouf/L3C-PyTorch/tree/master/src/torchac

torchac $ COMPILE_CUDA=auto python3 setup.py build
torchac $ python3 setup.py install --optimize=1 --skip-build

or (untested)

torchac $ pip install .

Once Ubuntu updates PyTorch then tensorboardX won’t be required

Copy the kodak dataset into datasets/test/kodak

cd ../common
python tools/wikidownloader.py --category "Category:Featured pictures on Wikimedia Commons"
python tools/wikidownloader.py --category "Category:Formerly featured pictures on Wikimedia Commons"
python tools/wikidownloader.py --category "Category:Photographs taken on Ektachrome and Elite Chrome film"
mv "../../datasets/Category:Featured pictures on Wikimedia Commons" ../../datasets/FeaturedPictures
mv "../../datasets/Category:Formerly featured pictures on Wikimedia Commons" ../../datasets/Formerly_featured_pictures_on_Wikimedia_Commons
mv "../../datasets/Category:Photographs taken on Ektachrome and Elite Chrome film" ../../datasets/Photographs_taken_on_Ektachrome_and_Elite_Chrome_film
python tools/verify_images.py ../../datasets/FeaturedPictures/
python tools/verify_images.py ../../datasets/Formerly_featured_pictures_on_Wikimedia_Commons/
python tools/verify_images.py ../../datasets/Photographs_taken_on_Ektachrome_and_Elite_Chrome_film/

# TODO make a list of train/test img automatically s.t. images don't have to be copied over the network

Crop images to 1024*1024. from src/common: (in python)

import os
from libs import libdsops
for ads in ['Formerly_featured_pictures_on_Wikimedia_Commons', 'Photographs_taken_on_Ektachrome_and_Elite_Chrome_film', 'FeaturedPictures']:
    libdsops.split_traintest(ads)
    libdsops.crop_ds_dpath(ads, 1024, root_ds_dpath=os.path.join(libdsops.ROOT_DS_DPATH, 'train'), num_threads=os.cpu_count()//2)

#verify crops
python3 tools/verify_images.py ../../datasets/train/resized/1024/FeaturedPictures/
python3 tools/verify_images.py ../../datasets/train/resized/1024/Formerly_featured_pictures_on_Wikimedia_Commons/
python3 tools/verify_images.py ../../datasets/train/resized/1024/Photographs_taken_on_Ektachrome_and_Elite_Chrome_film/
# use the --save_img flag at the end of verify_images.py commands if training fails after the simple verification

Move a small subset of the training cropped images to a matching test directory and use it as args.val_dpath

JPEG/BPG compression of the Commons Test Images is done with common/tools/bpg_jpeg_compress_commons.py and comp/tools/bpg_jpeg_test_commons.py

Loading a model: provide all necessary (non-default) parameters s.a. arch, num_distributions, etc.
Saved yaml can be used iff the ConfigArgParse patch from https://github.com/trougnouf/ConfigArgParse is applied,
otherwise unset values are overwritten with the “None” string.

Train a base model (given arch and num_distributions) for 6M steps at train_lambda=4096, fine-tune for 4M steps with lower train_lambda and/or msssim lossf
Set arch to Manypriors for this work, use num_distributions 1 for Balle2017, or set arch to Balle2018PTTFExp for Balle2018 (hyperprior)
egrun:

python train.py --num_distributions 64 --arch ManyPriors --train_lambda 4096 --expname mse_4096_manypriors_64_CLI
# and/or
python train.py --config configs/mse_4096_manypriors_64pr.yaml
# and/or
python train.py --config configs/mse_2048_manypriors_64pr.yaml --pretrain mse_4096_manypriors_64pr --reset_lr --reset_global_step # --reset_optimizer
# and/or
python train.py --config configs/mse_4096_hyperprior.yaml

–passthrough_ae is now activated by default. It was not used in the paper, but should result in better rate-distortion. To turn it off, change config/defaults.yaml or use –no_passthrough_ae

egruns:
Test complexity:

python tests.py --complexity --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64

Test timing:

python tests.py --timing "../../datasets/test/Commons_Test_Photographs" --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64

Segment the images in commons_test_dpath by distribution index:

python tests.py --segmentation --commons_test_dpath "../../datasets/test/Commons_Test_Photographs" --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64

Visualize cumulative distribution functions:

python tests.py --plot --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64

Test on kodak images:

python tests.py --encdec_kodak --test_dpath "../../datasets/test/kodak/" --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64

Test on commons images (larger, uses CPU):

python tests.py --encdec_commons --test_commons_dpath "../../datasets/test/Commons_Test_Photographs/" --pretrain checkpoints/mse_4096_manypriors_64pr/saved_models/checkpoint.pth --arch ManyPriors --num_distributions 64

Encode an image:

python tests.py --encode "../../datasets/test/Commons_Test_Photographs/Garden_snail_moving_down_the_Vennbahn_in_disputed_territory_(DSCF5879).png" --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64 --device -1

Decode that image:

python tests.py --decode "checkpoints/mse_4096_manypriors_64pr/encoded/Garden_snail_moving_down_the_Vennbahn_in_disputed_territory_(DSCF5879).png" --pretrain mse_4096_manypriors_64pr --arch ManyPriors --num_distributions 64 --device -1

Minecraft StatsViewer – or StatsViewer – is a (mostly) standalone Java program that reads minecraft server / world files and displays statistics and other information in a human-consumable format. It also displays biomes and structures.
StatsViewer uses Java Swing (AWT) to have a fairly consistent and usable interface that easily keeps track of the information it processes.

1. Feature List
2. Dependencies
3. Installation
4. Quick Start
5. The Problem
6. Audience
7. Documentation
   • Source File Structure
   • Library Resources
     • ListPanel and QuantityLabel
     • MinecraftPlayer class
     • World class
   • Contribution
     • How to code in this project
     • Future Plans
     • Acknowledgements

• Previously opened server storage
• User & UUID display
• Display users’ inventory, advancements, statistics, and filenames
• Display world’s seed, name, version, and gamerules
• Display biomes and structures
• Threading and progress info to keep the UI responsive
• Sort all information by related values, such as slots, A-Z, and count
• High performance allowing for rapid development and expansion
• Detailed and extensive library of code to make it easy to expand codebase

• A JDK / JRE able to run Java 17+ programs
  • If you haven’t installed, you can get it here
  • Make sure you have the java command in your path
  • Use java --version to check if it is installed

• Install any dependencies and have them accessible in path
• Download the jarfile and put it in a directory to run it that is not a minecraft server
• Run the program, and select the folder of a minecraft server
  • has server.properties, and usercache.json in it
  • has a world folder, which has a level.dat folder
  • has write permissions so that a .statsviewer directory can be made

1. Download the jarfile from the releases page
2. Run the jarfile
3. Select the directory of a minecraft server
4. Press “Confirm” to load in the data
5. Select a user or world to view the information
6. Press “Exit” to close the program
7. In future runs, the server will be saved in the “Recent Servers” list

This program serves to solve a quite niche problem that I found in the way minecraft servers and minecraft worlds are stored. I was making a scoreboard on my server to keep track of how many sticks someone has crafted (something to do with fletchers, don’t ask). The issue is, when creating the scoreboard, it doesn’t automatically populate- instead, the admin needs to check his own stats, and check the stats files of all the users of the server. This is slow, annoying, and sometimes inconsistent.

TLDR: I wanted to see the statistics of all the users of my server at a glance, and I didn’t want to have to go through the stats files of all the users to do it. So I made this program.

This is a program that visualizes information that a server admin might want to see at a glance. It not only shows statistics, which was the original purpose, but it shows inventory / enderchest content, achievements, world information, and gamerules, all in a nicely organized cross-platform view. It is completely standalone, because programs that require installation and ingrain themselves into your system are my pet peeve. The only thing the program stores is decompressed .dat files in a new directory in your server files, which makes it easier to debug and to do any other work yourself.

Most important files have extensive documentation with examples on how to use it.
Some information can not be fit into standard documentation format, so it is provided below.

The StatsViewer program is organized into three packages with (mostly) separate purposes.
Here is a brief overview of the packages and their contents:

• main – The main package. Contains the main class, and the classes that manage the GUI and the program.

  • BlankPanel.java – The first page of the program. It handles server selection and tracking.
  • DialogManager.java – The static class that manages the progress bar popups.
  • MainPanel.java – The second page of the program. It displays player info, world info, and handles most interactions.
  • StatsViewer.java – The main class. It starts the program and handles the main GUI.

• util – The utility package. Contains libraries, utilities, and global state management.

  • DataParsing.java – Contains utility functions for files, JSON parsing, and NBT parsing.
  • Globals.java – The main manager of global state and constants. It is mostly static.
  • Utility.java – The main library of utility functions. It is mostly static.

• components – The AWT component package. Each class is a component that is used in the main GUI.

  • BottomPanelPlayers.java – The bottom section for the players view. Handles the player list and the player view.
  • BottomPanelWorlds.java – The same as BottomPanelPlayers, but for worlds.
  • ListPanel.java – A utility component that lists strings, and provides dynamic sorting functionality.
  • PlayerView.java – A wrapper class for the MinecraftPlayer class. It displays the player’s information.
  • QuantityLabel.java – A utility component, which is a JLabel but with more data for sorting purposes.
  • TopPanel.java – The top section of the program. Contains the server selection and the exit button.
  • WorldMapPanel.java – The panel that displays the biome and structure map, and region selection.
  • WorldView.java – A wrapper class for the World class. It displays the world’s information.

• player – The player data package. Mostly static classes, but the Item class is not.

  • Advancement.java – The class that stores advancement data. Deserialized by Gson.
  • Inventory.java – The class that stores inventory data. Deserialized by Gson.
  • MinecraftPlayer.java – Contains a player’s inventory, stats, and caching info.
  • Item.java – The class that stores item data. Deserialized by Gson.
  • UsercachePlayer.java – The class that stores usercache data. Deserialized by Gson.

• world – The world data package. Mostly static classes.

  • Chunk.java – The class that stores chunk data, and file locators.
  • RegionParser.java – The class that handles all decompression and parsing of region files.
  • World.java – The class that stores world data.
  • WorldGenSettings.java – The class that stores world generation settings. Deserialized by Gson.

You can use the ListPanel in conjunction with the QuantityLabel objects to make a dynamic and sortable list of entries, with many helper functions to make things easier. Here is a basic example of making a ListPanel that keeps track of names, and allows sorting alphabetically.

// a given list of items to display
String[] names = { "Bob", "Jane", "Sam", "Al", "Joe", "Jeff", ...};

// create the panel
ListPanel namePanel = new ListPanel(
    500, 250, // set the dimensions of the panel
    ListPanel.ALL_AZ_OPTIONS, // use the alphabetical sorting options
    ListPanel.SORT_AZ // select sort A->Z as default
);
namePanel.add(new JLabel("Name List")); // add a title

// add the labels, sortable by name and length
for (String name : names) {
    namePanel.addLabel(name, name.length());
}

// add the panel wherever you want
frame.add(namePanel);

The class also allows you to update the list of items whenever you want, by sorting it, appending it, removing entries, or just clearing it.

// add previous code...

// sort the labels
namePanel.sortLabels(ListPanel.SORT_ZA);
namePanel.sortLabels(ListPanel.SORT_SLOT_LEAST);

// add some labels
namePanel.addLabel("Ethan", "Ethan".length());
namePanel.addLabel("Ben", "Ben".length());

// clear the labels
namePanel.clearLabels();

As you may have noticed, there are quite a few ways to add labels to the ListPanel. Here is a list of every option.

storePanel.addLabel("Apple", 2.99, 20); // Name, count, and slot
storePanel.addLabel("Grapes", 4.99); // Name, count
storePanel.addLabel(new JLabel("Orange")); // JLabel object
storePanel.addPanel(new QuantityLabel(...)); // QuantityLabel object

Even though the values in the quantity label are named name, count, and slot, they can easily be modified visually, and the QuantityLabel class can easily be expanded. It is strongly recommended to wrap the ListPanel into a JPanel, because otherwise, the ListPanel will not display properly. This can easily be done by adding the ListPanel to a JPanel, and then adding the JPanel to the frame.

JPanel panel = new JPanel();
panel.add(namePanel);
frame.add(panel);

The MinecraftPlayer class is a class that manages the deserialization and storage of information related to a player. It stores data from the playerdata, stats, and advancements folder, as well as making basic calculations from data found in level.dat and usercache.json. In order to fully populate the player object, there are some steps to deserialization and parsing, shown below.

// load in files
File usercacheFile = new File("path/to/usercache.json");
File playerFile = new File("path/to/playerdata/player.json");
File statsFile = new File("path/to/stats/player.json");
File advancementsFile = new File("path/to/advencements/player.json");

// create the gson parser
Gson gson = new GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .create();
    
// read in the usercache file and create a usercache
List<UsercachePlayer> usercache = new ArrayList<UsercachePlayer>();
JsonArray usercacheJson = gson.fromJson(
    Lib.fileToString(usercacheFile), 
    JsonArray.class
);
for (JsonElement usercacheElement : usercacheJson) {
    usercache.add(gson.fromJson(usercacheElement, UsercachePlayer.class));
}

// Create the player
MinecraftPlayer player = gson
    .fromJson(Lib.fileToString(playerFile), MinecraftPlayer.class)
    .addUUID()
    .addName(usercache)
    .addStats(statsFile, server)
    .addAdvancements(advancementsFile, server);

As seen above, the Gson library does much of the heavy lifting of reading raw JSON files. However, by default, Gson does not handle NBT files, so the de-nbt.py script is used to convert the NBT files into JSON files. It can easily be accessed with Lib.execute("python3", "de-nbt.py", "original.nbt", "new.json"). The MinecraftPlayer class also has many methods to display the information in a human-readable format, and to compare the information with other players.

The World class is a class that manages the deserialization and storage of information related to a world. It stores data from the level.dat file, as well as making basic calculations from data found in the world folder. It is entirely deserialized with Gson, and is very simple to use. The only thing that needs to be done is to reformat the NBT files into JSON files, as per usual, and then make sure to use the formatEpoch method to convert the epoch time into a human-readable format.

World world = gson.fromJson(Lib.fileToString(levelFile), World.class); // Create the world
String formattedTime = Lib.formatEpoch(world.lastPlayed); // format the last played time

Lastly, the PlayerView and WorldView classes are simple wrapper classes that when used in conjunction with Java Swing, display a Player or World object, respectively. They include all useful information about the object, and are easily expandable. As they are wrapper classes, they can easily be used, as seen below.

// For players
PlayerView playerView = new PlayerView();
playerView.setPlayer(player);

// For worlds
WorldView worldView = new WorldView();
worldView.setWorld(world);

This project is fully open sourced, so just make a PR if you want to change something. The Issues tab is also great, so put any requests or bugs there. I plan on improving this program but I am at a bit of a dead end.

This section is about where a bug might be:

• Something with the display of a player: MinecraftPlayer, PlayerView
• Something with the display of a world: World, WorldView
• Something with files not being read: Globals, Utility
• Something with the main UI components: ListPanel, QuantityLabel, the components module, UsercachePlayer

Those are the most common bugs I found during developement, and what file(s) they tended to be caused by.
Now, here are the core design principles of this project. I try to follow these while coding, so if you contribute, you should as well:

1. Keep things componentized
   • Each file / function does ONLY what it is meant to do. This means no .draw, .update, or .doEverything
   • The MinecraftPlayer class is just for storing players, the World class is just for storing worlds, etc
2. Library functions stay isolated and somewhat pure
   • The Lib class has no internal state
   • Any library functions / helper functions in the project go there
3. Use TABS / FOUR SPACES!
   • I am in the process of auto-formatting the whole project so yeah
   • Tabs > four spaces, I will die on this hill
4. Make useful code
   • Even if your code isn’t exactly the best, it isn’t perfect, thats fine
   • Code is meant to run fast, and correctly. If your code does that, great
   • Coding is fun. Don’t ruin that for me 😉

• A way to edit the world’s gamerules
• Some information from region and entity files (don’t know what yet)
• A way to edit the player’s inventory and stats (worried, because it might delete the player’s data so I need to be careful)
• more interesting formatting for the other tab in stats (make cm -> km, etc)
• performance improvements / logging

Thank you for reading through the documentation. If you have any questions or comments, reach out to me in the social media platforms in my profile. Submit a bug report or a PR if there are any issues or features you would like to see (or not see). Have a great day!

The liscense for Gson can be viewed here.
The liscense for nbtlib can be viewed here.
The liscense for this project can be viewed here.

This project is not affiliated with, endorsed by, or associated with Mojang Studios or Microsoft, thecreators and owners of Minecraft. Minecraft is a trademark of Mojang Studios, and all related assets andintellectual property belong to their respective owners. This project is an independent creation developed by Nathaniel Levison and is not sponsored, authorized, or approved by Mojang Studios or Microsoft.

Nate Levison, February 2024

Content

• vscode-micromamba
  • The Aim
  • Commands
  • Global home directory
  • DotEnv file support
  • Multi-root workspaces
  • How to get it?
  • Maintainers
  • Want to Contribute?
  • License

Provide a convenient way to install developer tools in VSCode workspaces from conda-forge with micromamba. Get NodeJS, Go, Rust, Python, or JupyterLab installed by running a single command.

Inspired by Robocorp RPA developer tools:

• RCC – a command-line tool to run software robots and integrate with the Robocorp Cloud
• Robocorp Code – a VSCode extension to build software robots

This command creates a file – environment.yml describing configuration. The environment.yml is a mamba environment file The extension comes with a number of templates, but you could change it to your needs and re-run the init command.

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba create environment
3. Choose a template from a list
4. The environment is activated automatically

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba deactivate environment

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba activate environment
3. Choose an environment from a list of created environments

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba remove environment
3. Choose an environment from a list of created environments

Clear all command, removes micromamba and packages, and reset the environment to the initial state.

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba clear all

Activate an environment created outside of the vscode-micromamba extension.

1. Open the command palette (Ctrl+Shift+P)
2. type – micromamba activate by path

Store micromamba files and environments for all projects in one global directory.

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba use global home directory

Store micromamba files and environments in the .micromamba directory inside the project.

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba use local home directory

This is a default behavior

Update micromamba to the latest version.

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba self update

Micromamba updates each time before creating a new environment

Show output pane and select micromamba source

1. Open the command palette (Ctrl+Shift+P)
2. Type – micromamba show output

The extension works locally by default when all additional files are created in the <workspaceRoot>/.micromamba directory. Switching to global home directory mode is also possible when files for all projects are stored in one place.

1. A fully encapsulated installation per project – all files are inside the project directory
2. Nothing left behind when the project gets deleted
3. Easy to investigate the content of the micromamba environments

1. Use less disk space and could be faster to create environments because packages are cached globally
2. Micromamba files inside the project directory could conflict with other tools. E.g., yarn doesn’t like local mode in combination with the module node package type.

On Linux and Mac, the global home directory is always $HOME/.vscode-micromamba

On Windows, the extension asks to provide a path to the global home directory. It’s recommended to make the path as short as possible to minimize MAX_PATH problems, especially when using Python.

DotEnv file is a convenient way to provide environment variables to other extensions or user scripts. Each time a user creates or activates an environment, a ~/.micromamba/.env.{prefix-name} file is created.

With multi-root workspaces, all operations will work the same way as if you open the first workspace folder in VSCode. The idea is that the first workspace folder is a target folder.

Let’s say you have a project.code-workspace with content:

{
  "folders": [
    {
      "path": "folderA"
    },
    {
      "path": "folderB"
    }
  ]
}

Assuming folders are already created, when you open the workspace in VSCode and command to create a micromamba environment, you’ll see the following directory structure:

.
├── folderA
│   ├── .micromamba
│   └── environment.yml
├── folderB

Simply open Micromamba – Visual Studio Marketplace and click Install. Alternatively, open Visual Studio Code, go to the extension view and search for Micromamba.

For detailed releases and migration help, please see releases.

Michael Borisov (@corker).

Thanks for considering! Check here for useful tips and guidelines.

We use a shared copyright model that enables all contributors to maintain the copyright on their contributions.

This software is licensed under the BSD-3-Clause license. See the LICENSE file for details.