Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Is your feature request related to a problem? Please describe. A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
Describe the solution you'd like A clear and concise description of what you want to happen.
Describe alternatives you've considered A clear and concise description of any alternative solutions or features you've considered.
Additional context Add any other context or screenshots about the feature request here.
Is your feature request related to a problem? Please describe. A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
Describe the solution you'd like A clear and concise description of what you want to happen.
Describe alternatives you've considered A clear and concise description of any alternative solutions or features you've considered.
Additional context Add any other context or screenshots about the feature request here.
Luxoria Desktop Software (Main Release)
Luxoria is a powerful all-in-one photography solution designed to streamline your workflow. Whether you are an individual photographer or part of a team, Luxoria makes it easy to manage and enhance your images, collaborate with clients, and deliver exceptional results.
Luxoria offers photographers a comprehensive solution to optimize their image workflow. Our desktop application simplifies the process of importing, organizing, editing, and exporting images, while our web platform enables easy sharing and client feedback. The platform ensures photographers can focus on their creative process while effortlessly managing their projects.
Import images directly from your camera or storage devices.
Organize your photos into albums and collections.
Edit with a wide range of powerful editing tools, including AI enhancements.
Collaborate with clients to refine and finalize image selections.
Share images via a web gallery.
Allow clients to view and select their favorite photos.
Collect feedback directly from clients in real-time.
Image Importation: Seamless image import from cameras or local storage.
Smart Organization: Organize images into albums, collections, or folders based on date, location, camera settings, and more.
Advanced Filters: Search and filter images by metadata, including date, location, and camera settings.
Editing Tools: Utilize a variety of editing tools such as cropping, color correction, retouching, and AI-powered enhancements.
Download and Install: Download the Luxoria desktop application from our website and follow the installation steps.
Set Up: Import your first batch of photos and start organizing your library.
Explore Features: Try out the editing tools, filters, and collaborative workflows.
Share with Clients: Upload selected photos to the web platform and invite clients to review and provide feedback.
Luxoria is more than just a photo editing tool, it's a complete photography management platform. From the moment you capture a shot, Luxoria ensures your photos are organized, edited, and shared efficiently. With AI-powered tools, intuitive collaboration features, and an easy-to-use interface, Luxoria is designed for photographers who want to focus on creativity while streamlining their workflow.
Luxoria is licensed under the Apache 2.0 License. See the file for more details.
Feel free to contribute or explore the codebase. Luxoria is constantly evolving, and we welcome your feedback and suggestions!
Describe the bug A clear and concise description of what the bug is.
To Reproduce Steps to reproduce the behavior:
Go to '...'
Click on '....'
Scroll down to '....'
To run the Catalyst demo, first install the npm dependencies:
Next, run the development server:
Finally, open in your browser to view the website.
See error
Expected behavior A clear and concise description of what you expected to happen.
Screenshots If applicable, add screenshots to help explain your problem.
Desktop (please complete the following information):
OS: [e.g. iOS]
Browser [e.g. chrome, safari]
Version [e.g. 22]
Smartphone (please complete the following information):
Device: [e.g. iPhone6]
OS: [e.g. iOS8.1]
Browser [e.g. stock browser, safari]
Version [e.g. 22]
Additional context Add any other context about the problem here.
Describe the bug A clear and concise description of what the bug is.
To Reproduce Steps to reproduce the behavior:
Go to '...'
Click on '....'
Scroll down to '....'
See error
Expected behavior A clear and concise description of what you expected to happen.
Screenshots If applicable, add screenshots to help explain your problem.
Desktop (please complete the following information):
OS: [e.g. iOS]
Browser [e.g. chrome, safari]
Version [e.g. 22]
Smartphone (please complete the following information):
Device: [e.g. iPhone6]
OS: [e.g. iOS8.1]
Browser [e.g. stock browser, safari]
Version [e.g. 22]
Additional context Add any other context about the problem here.
Describe the bug A clear and concise description of what the bug is.
To Reproduce Steps to reproduce the behavior:
Go to '...'
Click on '....'
Scroll down to '....'
See error
Expected behavior A clear and concise description of what you expected to happen.
Screenshots If applicable, add screenshots to help explain your problem.
Desktop (please complete the following information):
OS: [e.g. iOS]
Browser [e.g. chrome, safari]
Version [e.g. 22]
Smartphone (please complete the following information):
Device: [e.g. iPhone6]
OS: [e.g. iOS8.1]
Browser [e.g. stock browser, safari]
Version [e.g. 22]
Additional context Add any other context about the problem here.
See RECAP_20_11_2024, RECAP_12_06_2025, RECAP_03_04_2025, RECAP_03_04_2025_1
https://www.nuget.org/packages/Luxoria.Algorithm.BrisqueScore, See : 1, 2
+2700 Downloads as of 22/06/2025
https://www.nuget.org/packages/Luxoria.SDK#readme-body-tab, See : 3
https://www.nuget.org/packages/Luxoria.Algorithm.YoLoDetectModel, See : 4
https://www.nuget.org/packages/Luxoria.Algorithm.YoLoDetectModel, See : 5
https://hub.docker.com/r/luxoria/luxstudio (+736 Downloads)
https://hub.docker.com/r/luxoria/luxapi (+539 Downloads)
https://github.com/LuxoriaSoft/Luxoria (+971 commits)
An average of 25 unique visitors per 15 days
https://docs.luxoria.bluepelicansoft.com
Is your feature request related to a problem? Please describe. A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
Describe the solution you'd like A clear and concise description of what you want to happen.
Describe alternatives you've considered A clear and concise description of any alternative solutions or features you've considered.
Additional context Add any other context or screenshots about the feature request here.
npm installnpm run devExport to multiple formats with one-click options.
Collaboration Tools: Work directly with clients to review and approve images. Gather input via comments, selections, or ratings.
Export Flexibility: Export images to multiple formats like JPEG, PNG, TIFF, or PDF with adjustable quality settings.
Web Sharing: Share albums with clients through a custom web platform for easy viewing and feedback.
Feedback Mechanism: Clients can provide individualized feedback, ensuring the final deliverables meet expectations.

We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
Examples of behavior that contributes to a positive environment for our community include:
Demonstrating empathy and kindness toward other people
Being respectful of differing opinions, viewpoints, and experiences
Giving and gracefully accepting constructive feedback
Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
Examples of unacceptable behavior include:
The use of sexualized language or imagery, and sexual attention or advances of any kind
Trolling, insulting or derogatory comments, and personal or political attacks
Public or private harassment
Publishing others' private information, such as a physical or email address, without their explicit permission
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at [email protected]. All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
Community Impact: A violation through a single incident or series of actions.
Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
Community Impact: A serious violation of community standards, including sustained inappropriate behavior.
Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
Consequence: A permanent ban from any sort of public interaction within the community.
This Code of Conduct is adapted from the , version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by .
For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
This document defines the manual test protocol for building and validating Luxoria.App and its associated modules and components on three target architectures: x64, x86, and ARM64. Each module LuxImport, LuxFilter, LuxEditor, LuxExport, LuxStudio and the standard component Marketplace is built and tested individually. Developers are responsible for executing and documenting all feature tests.
Build validation for Luxoria.App on x64, x86, ARM64.
Module assembly and feature verification for each module and the Marketplace component.
Manual test cases executed by module developers.
Source code checkout of Luxoria repository (latest main branch).
Visual Studio 2022 + WinUI Developpement Tool
Windows App 10/11/1X SDK
Windows 10/11
Open VS 2022
Load Luxoria.App.sln
Run Luxoria.App
Build each module such as
LuxImport
LuxFilter
LuxEditor
LuxExport
Execute each testing requirements (see below for specifications)
TEST 1:
Open an existing Collection : OK
TEST 2:
Open a new folder, then create a new name and click on import : OK
Success : A pop-up is being displayed after the importation has been completed
TEST 1:
Check Brisque Algorithm Click on Save / Sync : OK
TEST 2:
Check CLIP Model Click on Save / Sync: OK
TEST 3:
Select another model/algorithm Click on Save / Sync : OK
TEST 1:
Tricks some parameters : OK
TEST 2:
Tricks some parameters Crop image : OK
TEST 3:
Tricks some parameters Crop the image Use the layer system Crop image : OK
TEST 1:
Export as PNG : OK
TEST 2:
Export as other format Usage of watermark : OK
TEST 3:
Export as other format Usage of watermark (icon) Usage of naming template : OK
TEST 1:
Connect to Studio : OK
TEST 2:
Connect to Studio : OK Export to studio : OK
For any bug found, please create an issue here : https://github.com/LuxoriaSoft/Luxoria/issues
This is the official documentation for the Luxoria project.
To use this documentation, simply navigate to the desired section, please navigate in the selected section to find the desired information.
If you are ready to start developing, please follow the .
Always use the latest version of the documentation.
If you find any errors, please report them.
If you have any suggestions, please let us know.
If you want to contribute, please follow the .
If you want to contribute to this documentation, please follow the .
BenchmarkDotNet v0.14.0, Windows 11 (10.0.26100.2894) Apple Silicon, 6 CPU, 6 logical and 6 physical cores .NET SDK 9.0.102 [Host] : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD DEBUG DefaultJob : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD
This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 <script setup> SFCs, check out the to learn more.
Learn more about the recommended Project Setup and IDE Support in the .
Run dotnet ef migrations add InitialCreate in the LuxAPI directory
Run dotnet ef database update in the LuxAPI directory
Run dotnet run in the LuxAPI directory
https://github.com/microsoft/vcpkg/issues/44310
See 2
https://github.com/microsoft/WindowsAppSDK/issues/5212
See 3
https://github.com/microsoft/microsoft-ui-xaml/issues/6299#issuecomment-2630463213 https://github.com/microsoft/microsoft-ui-xaml/discussions/8670#discussioncomment-12039153
See : 4 & 5
https://github.com/microsoft/microsoft-ui-xaml/discussions https://github.com/mono/SkiaSharp/discussions
https://openaccess.thecvf.com/content_CVPR_2019/papers/Liu_An_End-To-End_Network_for_Panoptic_Segmentation_CVPR_2019_paper.pdf 8
https://pub.ista.ac.at/~vnk/papers/grabcut_siggraph04.pdf 10
Benchmarking Technologies See Benchmark.pdf
For technologies : See TECH_STACKS.pdf
For dependencies : See DEPENDENCIES.pdf
The team reviewed storage strategies for our LuxStudio Solution. We initially considered migrating from a document-DB approach to a traditional file-system model. However, after evaluating long-term modularity, performance, and maintainability, we unanimously agreed to pursue a bucket-style database solution using MinIO.
LuxStudio assets are presently stored in a document-oriented database.
Concerns were raised about scalability and operational complexity.
Pros:
Simplifies backup and direct file access.
Cons:
Limited scalability in distributed environments.
Potential performance bottlenecks under heavy I/O loads.
Modularity:
MinIO’s S3-compatible API allows plug-and-play integration with existing cloud-native tooling.
Performance:
Distributed, erasure-coded clusters ensure high throughput and fault tolerance.
Sustainability:
Easier maintenance and upgrades via rolling updates.
Broad community and commercial support.
Adopt a bucket-style object storage solution using MinIO for all LuxStudio asset storage moving forward.
Prototype MinIO deployment (single-node) and validate core APIs.
Benchmark read/write performance against existing document-DB setup.
Draft architecture diagram and integration plan with LuxStudio
Review security and backup strategies for MinIO cluster
Focusing on what is best not just for us as individuals, but for the overall community
Other conduct which could reasonably be considered inappropriate in a professional setting

0.100 ns
-
-
-
-
ComputeSharpness
1,247,542,131.41 ns
4,759,688.559 ns
3,974,555.516 ns
94000.0000
-
-
396981440 B
ComputeBrisque
167,962,263.89 ns
936,623.349 ns
731,253.903 ns
-
-
-
1296 B
ComputeResolution
18.65 ns
0.113 ns
9,645.05 μs
23,840.17 μs
BenchmarkLoadAssets
8,870,859.5 μs
526,318.08 μs
1,535,294.66 μs
BenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4751/23H2/2023Update/SunValley3)
Apple Silicon, 4 CPU, 4 logical and 4 physical cores
.NET SDK 9.0.102
[Host] : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD
DefaultJob : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD
BenchmarkIsInitialized
204.7 μs
2.38 μs
2.11 μs
BenchmarkInitializeDatabase
199.3 μs
2.29 μs
2.14 μs
BenchmarkIndexCollectionAsync
487,436.6 μs
-
-
ComputeSharpness
1,247,542,131.41 ns
4,759,688.559 ns
3,974,555.516 ns
94000.0000
-
-
396981440 B
ComputeBrisque
167,962,263.89 ns
936,623.349 ns
731,253.903 ns
-
-
-
1296 B
ComputeResolution
18.65 ns
0.113 ns
0.100 ns
-
-
BenchmarkDotNet v0.14.0, Windows 11 (10.0.26100.2894)
Apple Silicon, 6 CPU, 6 logical and 6 physical cores
.NET SDK 9.0.102
[Host] : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD DEBUG
DefaultJob : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD
Core Adjustments White balance (Temperature/Tint), Exposure, Contrast, Highlights/Shadows, Whites/Blacks.
Presence & Color Control Texture, Dehaze, Vibrance, Saturation for quick pop without overcooking.
Pro Tone Curve Intuitive curve editor (RGB & channels) for precise tonal shaping.
Crop & Layers Fast cropping plus layer-based workflows for organized edits.
Subject Recognition (Mask-Ready) Kickstart local edits with one-click subject detection.
Presets & Quick Culling One-click looks, star/flag tools, and a film-strip for rapid review.
Inline EXIF/Metadata Viewer See camera data while you edit, no context switching.
Reset & Compare, Undo/Redo Confidence to experiment, with instant safety nets.
Clean, Focused UI Editor, Crop, Layers, Export tabs, everything where you expect it.
Open Pick photos from your Collection Importer (LuxImport)
Filter Thanks to LuxFilter, apply filters (quality, scores, ranking, etc.) to select the best subset
Adjust Start with Basic (WB, Tone, Presence), then refine with Curve or Layers.
Mask Manual masks for targeted edits.
Export Send to Export with your preferred format and quality settings.
Customizable shortcuts and a lightweight plugin API
Luxoria and all standard modules are licensed under the Apache 2.0 License.
See the LICENSE for details.
Feel free to contribute or open issues - LuxEditor evolves with your feedback!
Fixes #<issue_number> Closes #<issue_number>
Provide a brief description of how you tested your changes. Include details about the environment and test cases used.
Attach any screenshots that help illustrate the changes made in this PR.
Add any additional information or context about the PR here.
Automatic Sync with File System Detects new photos added or removed from your folders and updates the database instantly.
Real-Time Change Tracking Keeps your collection fully aligned with the source folders, so your database always reflects the latest state.
Scalable for Large Libraries Optimized to handle thousands of photos without slowing down.
Clean & Intuitive Interface Minimal, elegant UI designed for both speed and usability.
Initialize Select a folder containing your photos. LuxImport automatically builds your database.
Stay Synced Add, delete, or modify photos in your folder. LuxImport keeps track automatically.
Enjoy Always access a clean, updated photo library with zero manual effort.
Advanced tagging & metadata support
Multi-source importation (using multiple folders, NAS, OneDrive, direct from camera)
Luxoria and all standard modules are licensed under the Apache 2.0 License. See the LICENSE file for more details.
Feel free to contribute or explore the codebase. Luxoria is constantly evolving, and we welcome your feedback and suggestions!
Date & Time: 3 April 2025 2PM
Attendees:
Yoo, Y
Noah GOSCINIAK
Yoo, Young Joon shared expert insights on modern computer vision segmentation techniques. Key recommendations included U-Net variants and Fully Convolutional Network (FCN) deep learning models to address our image segmentation needs.
Importance of precise pixel-level classification for our use cases (e.g., medical imagery, scene understanding).
Architecture: Encoder–decoder with skip connections for fine-grained feature recovery.
Variants:
U-Net++ (nested U-Net) for richer multi-scale feature fusion.
Attention U-Net to focus on relevant spatial regions.
Core Idea: Replace fully connected layers with convolutional layers for end-to-end segmentation.
Notable Models:
FCN-8s for coarse-to-fine upsampling.
DeepLab (atrous convolutions + CRF) for sharper boundaries.
Data Volume & Annotation Quality
Compute Resources & Inference Latency
Target Application Requirements (e.g., boundary precision vs. speed)
Evaluate and prototype both a U-Net variant and an FCN-based model on our dataset to compare accuracy, speed, and resource utilization.
Set up data pipeline and preprocess images for segmentation tasks Implement baseline U-Net and run initial training/validation Implement baseline FCN-8s (and DeepLab if resources allow) Compare metrics (IoU, pixel accuracy, inference time) Review results with Yoo, Young Joon and refine model selection
This is the official documentation for the Luxoria project.
If you are ready to start developing, please follow the .
To contribute to this documentation, please follow the steps below:
Click on the Fork button at the top right corner of the repository.
Clone the repository to your local machine using the following command:
Create a new branch using the following command:
Make the necessary changes to the documentation.
Commit the changes using the following command:
Push the changes to the repository using the following command:
Create a pull request from your forked repository to the original repository.
Date & Time: June 19, 2025 · 18:00
Attendees:
Léo F
Whole Luxoria Team
Initiated the LuxStudio refactor to enhance user experience and operational robustness. Key focus areas include UI improvements, English language fixes, automated Kubernetes deployments via CircleCI, and strengthened user security with hCaptcha and a two-step registration form.
Revamp layouts and controls for clearer workflows
Improve responsiveness and accessibility standards
Standardize component library for consistency
Audit existing UI text for grammar and clarity
Implement i18n framework to simplify future translations
Review error messages and tooltips for user-friendly wording
Define Kubernetes manifests (Deployments, Services, Ingress) under k8s/
Create CircleCI pipeline:
Build Docker image on merge to main
Embed hCaptcha on signup and login forms
Design double-form registration:
User enters email & password
System sends temporary code via email
Move forward with the full refactor as outlined, prioritizing UI polish and deployment automation in parallel, followed by security enhancements.
Draft UI mockups and component spec Perform UI text audit and integrate i18n library Define Kubernetes manifests and CircleCI config prototype Implement hCaptcha on auth pages and build registration flow Conduct end-to-end tests (UI, deployment, registration security) Update user documentation and release notes
The Smart Filtering Module
AI-Powered Filters Apply filters like Brisque (image quality), CLIP (semantic search), Resolution, and Sharpness to automatically evaluate assets.
Quality & Ranking Each filter generates scores you can use to rate, flag, or organize your collection.
Non-Destructive Evaluation Filtering only tags or scores items – your original assets remain unchanged.
Forward Sync Send selected and scored assets forward into other modules (e.g., LuxEditor, LuxExport) with one click.
Integrated Ratings & Flags View and manage ratings, flags, and filter scores in a dedicated side panel.
Simple Save & Sync Persist results for future sessions or sync directly with the workspace.
Import Bring in your media from LuxImport or other connected modules.
Filter Explorer Run AI-driven filters (Brisque, CLIP, Resolution, Sharpness) to evaluate asset quality.
Review Scores Check Rating, Flags, and Scores in the right-side panel to identify the best candidates.
More filter algorithms (noise, color harmony, aesthetics)
Batch filter pipelines with presets
Exportable filter profiles
Luxoria and all standard modules are licensed under the Apache 2.0 License.
See the for details.
The Standard Editing Module
Non-Destructive Editing Every change is stored as adjustments/layers, your originals stay untouched.
Core Adjustments White balance (Temperature/Tint), Exposure, Contrast, Highlights/Shadows, Whites/Blacks.
Presence & Color Control Texture, Dehaze, Vibrance, Saturation for quick pop without overcooking.
Pro Tone Curve Intuitive curve editor (RGB & channels) for precise tonal shaping.
Crop & Layers Fast cropping plus layer-based workflows for organized edits.
Subject Recognition (Mask-Ready) Kickstart local edits with one-click subject detection.
Presets & Quick Culling One-click looks, star/flag tools, and a film-strip for rapid review.
Inline EXIF/Metadata Viewer See camera data while you edit, no context switching.
Reset & Compare, Undo/Redo Confidence to experiment, with instant safety nets.
Clean, Focused UI Editor, Crop, Layers, Export tabs, everything where you expect it.
Open Pick photos from your Collection Importer (LuxImport)
Filter Thanks to LuxFilter, apply filters (quality, scores, ranking, etc.) to select the best subset
Adjust Start with Basic (WB, Tone, Presence), then refine with Curve or Layers.
Mask Manual masks for targeted edits.
Customizable shortcuts and a lightweight plugin API
Luxoria and all standard modules are licensed under the Apache 2.0 License.
See the for details.
Feel free to contribute or open issues - LuxEditor evolves with your feedback!
Luxoria Standard Modules (LuxStd Modules) are a collection of core modules designed to provide essential functionalities within the Luxoria ecosystem. These modules follow a standardized architecture, ensuring seamless integration, extensibility, and interoperability with other Luxoria components.
Modular Design: Each module follows a plug-and-play architecture.
Event-Driven: Modules communicate through event-based interactions using IEventBus.
Extensible: Can be enhanced with additional features without breaking compatibility.
LuxImport Handles the importation, indexing, and management of digital asset collections.
Processes large datasets with asynchronous operations and progress tracking.
LuxFilter Provides a filtering pipeline for processing and scoring digital assets.
Uses a modular filtering algorithm framework with weighted execution.
LuxExport Provides advanced export functionalities for asset collections.
Supports multi-format output, custom file naming, and export conflict resolution.
LuxStd Modules form the backbone of the Luxoria ecosystem, ensuring a robust, scalable, and modular approach to handling digital assets. Their event-driven and extensible design makes them ideal for a wide range of applications within the system.
Date & Time: 12 June 2025 6PM
Attendees:
Léo F
Whole Luxoria Team
Our current distribution process requires users to manually download a GitHub release, unzip it, and move files into Program Files. To streamline deployment and improve user experience, we have decided to develop a native executable installer.
Navigate to our GitHub repository’s “Releases” page
Download the .zip archive of the latest version
Extract contents locally
Manually move the application folder into C:\Program Files\…
Multiple manual steps prone to user error
No version-check or upgrade path
Lack of automated shortcut creation and uninstaller
Support overhead for installation issues
Executable Installer
Bundle binaries, assets, and dependencies
Automate directory placement under Program Files
Create Start menu/desktop shortcuts
Proceed with designing and building a native Windows executable installer for our application.
Research and select an installer framework (e.g., NSIS, Inno Setup, MSI) Develop a prototype executable installer Conduct cross-environment testing (Windows versions & permissions) Update documentation and publish installer on GitHub Releases
Tailwind Labs Inc. grants you an on-going, non-exclusive license to use the Components and Templates.
The license grants permission to one individual (the Licensee) to access and use the Components and Templates.
You can:
Use the Components and Templates to create unlimited End Products.
Pros & Cons:
Excellent performance with limited data.
– Higher memory footprint; may require patch-based training.
Pros & Cons:
Simpler architecture & faster inference.
– Can struggle with small object segmentation without additional post-processing.
Apply rolling updates to staging and production clusters
Integrate health-checks and rollback strategies
User submits code to complete account activation
Log and monitor failed attempts for anomaly detection
(Optional) Add to PATH or create desktop shortcuts
Provide an uninstaller entry in Control Panel
Potential Tools
NSIS, Inno Setup, Windows Installer (MSI)
Consider cross-platform options if needed in future
Main Branches:
main: Contains the production-ready code.
develop: Used as an integration branch for features, bugfixes, and hotfixes before releases.
Supporting Branches:
feat/*: For new features.
bugfix/*: For resolving bugs found during development.
hotfix/*: For urgent fixes in the production code.
Use the following prefixes for your branch names to maintain consistency:
feat/FEATURE_NAME: For new features.
bugfix/BUG_NAME: For bug fixes during development.
hotfix/HOTFIX_NAME: For critical fixes applied directly to main.
Use the following structure for writing clear, informative commit messages:
Format: <type>: <description>
Types:
feat: For new features (e.g., feat: Add image editing tool).
bugfix: For bug fixes (e.g., bugfix: Fix alignment issue).
hotfix: For critical bug fixes (e.g., hotfix: Fix crash on startup).
Add a brief description after the type, and make sure your message is concise and descriptive.
Each feature, bugfix, or hotfix should be accompanied by a pull request (PR). The steps are:
Open a PR targeting the develop branch.
Assign a reviewer for code review.
Ensure the PR passes all automated checks and tests.
Provide a detailed description of what was changed and why.
Every PR must undergo a code review before merging:
Reviewers should carefully check the changes for quality, readability, and correctness.
Provide constructive feedback.
Approve the PR if it meets the necessary standards.
Once your pull request has been reviewed and approved:
Ensure all checks pass before merging.
Merge into develop (or main in the case of hotfixes).
Delete the branch after merging to keep the repository clean.
We use Semantic Versioning for releases:
Major: Incompatible API changes or large-scale changes.
Minor: New features or functionality.
Patch: Bug fixes or minor updates.
Follow this versioning structure when preparing release branches.
Make sure the documentation is updated for each new feature, bugfix, or hotfix:
Update docs for in-depth documentation.
Update README.md for general project information.
Use DEVELOPMENT.md for developer guidelines.
Use CONTRIBUTING.md for contribution guidelines.
Update CHANGELOG.md with the history of changes.
Keep the LICENSE.md up-to-date with any changes in licensing.
All code changes must adhere to the Luxoria Unit Testing Policy to ensure high coverage, quality, and maintainability of the codebase.
Testing: Ensure all code changes are properly tested.
Code Style: Follow project-specific coding standards to maintain uniformity.
By following these guidelines, you help maintain a smooth and efficient development process at Luxoria.
Integrated Feedback Loop Clients can flag favorites, leave notes, or approve images directly in the app, streamlining the review process.
Support for Multiple Formats Share and export in JPEG, PNG, TIFF, RAW, and more, all configured from within the platform.
Unified Workflow Ecosystem Works hand-in-hand with LuxImport, LuxEditor, LuxFilter, and LuxExport to provide a full, end-to-end photo workflow, in one app.
Client-Centered UI Designed for intuitive use, clients don’t need training; they simply open, comment, and approve.
Cross-Platform Desktop App Works on your preferred OS, ensuring both editors and clients get a smooth native experience.
Collaborate After editing, initiate a client gallery in LuxStudio and share a link or invite directly.
Review & Comment Clients open the gallery in their web interface, indicate favorites, add comments, or approve.
Sync Feedback Responses sync back into Luxoria, allowing you to incorporate revisions or finalize selections.
Finalize & Export Confirm approved images and send them to Export module for batch export or delivery in desired formats.
Detailed permission controls (viewer vs. editor)
Branding options for client-facing gallery pages
Luxoria and all standard modules are licensed under the Apache 2.0 License.
See the LICENSE for full details.
Experience a frictionless creative-to-client loop, LuxStudio brings collaboration to the heart of your photo workflow.
Logging & Error Handling: Implements structured logging via ILoggerService for debugging and diagnostics.
Modular filtering pipeline with weighted algorithms
Event-driven architecture for processing notifications
Parallelized execution for optimized performance
Error handling for robust processing
Implements IModule
Handles initialization, execution, and shutdown
Provides logging for module actions
Manages the execution of filtering algorithms
Tracks progress and scores
Uses concurrency for efficiency
Defines a standard interface for filtering algorithms
Implements a scoring method based on image analysis
ResolutionAlgo: Evaluates the resolution of an image.
SharpnessAlgo: Measures the sharpness level in an image.
BrisqueAlgo: Uses the BRISQUE metric to assess perceptual quality.
Ensure that the Luxoria ecosystem is installed and configured properly.
Your project should reference the necessary LuxFilter libraries.
Implement and register IEventBus for event-driven interactions.
Clone or download the LuxFilter module.
Add the project reference in your Luxoria-based application.
Implement IModule interface in your module system.
Initialize the module using Initialize().
Configure the filtering pipeline using AddAlgorithm().
Pass image data through the Compute() function.
Subscribes to filtering events
Initializes logger and context
Uses AddAlgorithm(IFilterAlgorithm algorithm, double weight) to add algorithms
Ensures the total weight of all algorithms does not exceed 1.0
Processes images using Compute(IEnumerable<(Guid, SKBitmap)> bitmaps)
Applies each algorithm in the workflow to every image
Each image receives a final score based on weighted algorithm outputs
Results are returned as (Guid, double) tuples
Notifies when an image has been processed and scored
Notifies when the pipeline has finished executing
Uses ILoggerService for structured logs
Exception handling ensures robust error reporting
Logs execution times for performance analysis
Uses parallel processing for scoring
Implements concurrent data structures for thread safety
Optimized event-driven execution to reduce overhead
Dynamic algorithm tuning for real-time adjustments
Support for additional image formats
Graphical visualization of scores
LuxFilter provides a scalable and efficient filtering pipeline for processing images in the Luxoria ecosystem. Its modular design, event-driven execution, and parallel processing capabilities make it an ideal choice for large-scale image scoring and analysis.
Event-driven architecture with IEventBus integration
Asynchronous operations for improved performance
Modular and scalable design
Progress tracking through event notifications
Parallel processing for asset loading
Implements IModule
Handles initialization, execution, and shutdown
Listens to OpenCollectionEvent and triggers import process
Manages the actual import process
Tracks progress and sends updates via event notifications
Loads assets into memory
Handles metadata storage and retrieval
Ensures collection initialization and integrity
Stores per-asset configuration
Manages LuxCfg models in .lux/assets
Loads image assets efficiently
Uses SkiaSharp for image decoding
Ensure that the Luxoria ecosystem is installed and configured properly.
Your project should reference the necessary LuxImport libraries.
Implement and register IEventBus for event-driven interactions.
Clone or download the LuxImport module.
Add the project reference in your Luxoria-based application.
Implement IModule interface in your module system.
Initialize the module using Initialize().
Subscribe to the OpenCollectionEvent.
When an import request is triggered, LuxImport processes the collection.
Once completed, CollectionUpdatedEvent is published.
Subscribes to OpenCollectionEvent
Initializes logger and context
Checks if the collection path is valid and initialized
Reads metadata from manifest.json
Hashes and stores asset references
Uses parallel processing for efficiency
Loads assets into memory
Uses ImageDataHelper for efficient decoding
Publishes CollectionUpdatedEvent upon successful import
Triggers collection import
Sends progress updates
Notifies the system of import completion
Uses ILoggerService for structured logs
Exception handling ensures robust error reporting
Uses parallel processing in LoadAssets
Minimizes blocking I/O operations
Implements batch logging to prevent log spam
Cache system for faster re-imports
Support for more file formats
UI integration for progress monitoring
LuxImport is designed for efficient, modular asset importation and indexing within the Luxoria ecosystem. Its event-driven design and asynchronous processing make it highly scalable and reliable.
git clone REPOSITORY_URLgit checkout -b BRANCH_NAMEgit add .
git commit -m "COMMIT_MESSAGE"git push origin BRANCH_NAMEvar luxFilter = new LuxFilter();
luxFilter.Initialize(eventBus, context, logger);
luxFilter.Execute();public void Initialize(IEventBus eventBus, IModuleContext context, ILoggerService logger)public event EventHandler<(Guid, double)> OnScoreComputed;public event EventHandler<TimeSpan> OnPipelineFinished;var luxImport = new LuxImport();
luxImport.Initialize(eventBus, context, logger);
luxImport.Execute();public void Initialize(IEventBus eventBus, IModuleContext context, ILoggerService logger)_eventBus.Subscribe<OpenCollectionEvent>(HandleOnOpenCollectionAsync);_eventBus?.Publish(new CollectionUpdatedEvent(collectionName, collectionPath, assets));Export Send to Export with your preferred format and quality settings.
Modify the Components and Templates to create derivative components and templates. Those components and templates are subject to this license.
Use the Components and Templates to create unlimited End Products for unlimited Clients.
Use the Components and Templates to create End Products where the End Product is sold to End Users.
Use the Components and Templates to create End Products that are open source and freely available to End Users.
You cannot:
Use the Components and Templates to create End Products that are designed to allow an End User to build their own End Products using the Components and Templates or derivatives of the Components and Templates.
Re-distribute the Components and Templates or derivatives of the Components and Templates separately from an End Product, neither in code or as design assets.
Share your access to the Components and Templates with any other individuals.
Use the Components and Templates to produce anything that may be deemed by Tailwind Labs Inc, in their sole and absolute discretion, to be competitive or in conflict with the business of Tailwind Labs Inc.
Examples of usage allowed by the license:
Creating a personal website by yourself.
Creating a website or web application for a client that will be owned by that client.
Creating a commercial SaaS application (like an invoicing app for example) where end users have to pay a fee to use the application.
Creating a commercial self-hosted web application that is sold to end users for a one-time fee.
Creating a web application where the primary purpose is clearly not to simply re-distribute the components (like a conference organization app that uses the components for its UI for example) that is free and open source, where the source code is publicly available.
Examples of usage not allowed by the license:
Creating a repository of your favorite Tailwind Plus components or templates (or derivatives based on Tailwind Plus components or templates) and publishing it publicly.
Creating a React or Vue version of Tailwind Plus and making it available either for sale or for free.
Create a Figma or Sketch UI kit based on the Tailwind Plus component designs.
Creating a "website builder" project where end users can build their own websites using components or templates included with or derived from Tailwind Plus.
Creating a theme, template, or project starter kit using the components or templates and making it available either for sale or for free.
Creating an admin panel tool (like or ) that is made available either for sale or for free.
In simple terms, use Tailwind Plus for anything you like as long as it doesn't compete with Tailwind Plus.
Licensee is the individual who has purchased a Personal License.
Components and Templates are the source code and design assets made available to the Licensee after purchasing a Tailwind Plus license.
End Product is any artifact produced that incorporates the Components or Templates or derivatives of the Components or Templates.
End User is a user of an End Product.
Client is an individual or entity receiving custom professional services directly from the Licensee, produced specifically for that individual or entity. Customers of software-as-a-service products are not considered clients for the purpose of this document.
Tailwind Labs Inc. grants you an on-going, non-exclusive license to use the Components and Templates.
The license grants permission for up to 25 Employees and Contractors of the Licensee to access and use the Components and Templates.
You can:
Use the Components and Templates to create unlimited End Products.
Modify the Components and Templates to create derivative components and templates. Those components and templates are subject to this license.
Use the Components and Templates to create unlimited End Products for unlimited Clients.
Use the Components and Templates to create End Products where the End Product is sold to End Users.
Use the Components and Templates to create End Products that are open source and freely available to End Users.
You cannot:
Use the Components or Templates to create End Products that are designed to allow an End User to build their own End Products using the Components or Templates or derivatives of the Components or Templates.
Re-distribute the Components or Templates or derivatives of the Components or Templates separately from an End Product.
Use the Components or Templates to create End Products that are the property of any individual or entity other than the Licensee or Clients of the Licensee.
Use the Components or Templates to produce anything that may be deemed by Tailwind Labs Inc, in their sole and absolute discretion, to be competitive or in conflict with the business of Tailwind Labs Inc.
Examples of usage allowed by the license:
Creating a website for your company.
Creating a website or web application for a client that will be owned by that client.
Creating a commercial SaaS application (like an invoicing app for example) where end users have to pay a fee to use the application.
Creating a commercial self-hosted web application that is sold to end users for a one-time fee.
Creating a web application where the primary purpose is clearly not to simply re-distribute the components or templates (like a conference organization app that uses the components or a template for its UI for example) that is free and open source, where the source code is publicly available.
Examples of use not allowed by the license:
Creating a repository of your favorite Tailwind Plus components or template (or derivatives based on Tailwind Plus components or templates) and publishing it publicly.
Creating a React or Vue version of Tailwind Plus and making it available either for sale or for free.
Creating a "website builder" project where end users can build their own websites using components or templates included with or derived from Tailwind Plus.
Creating a theme or template using the components or templates and making it available either for sale or for free.
Creating an admin panel tool (like or ) that is made available either for sale or for free.
Creating any End Product that is not the sole property of either your company or a client of your company. For example your employees/contractors can't use your company Tailwind Plus license to build their own websites or side projects.
Licensee is the business entity who has purchased a Team License.
Components and Templates are the source code and design assets made available to the Licensee after purchasing a Tailwind Plus license.
End Product is any artifact produced that incorporates the Components or Templates or derivatives of the Components or Templates.
End User is a user of an End Product.
Employee is a full-time or part-time employee of the Licensee.
Contractor is an individual or business entity contracted to perform services for the Licensee.
Client is an individual or entity receiving custom professional services directly from the Licensee, produced specifically for that individual or entity. Customers of software-as-a-service products are not considered clients for the purpose of this document.
If you are found to be in violation of the license, access to your Tailwind Plus account will be terminated, and a refund may be issued at our discretion. When license violation is blatant and malicious (such as intentionally redistributing the Components or Templates through private warez channels), no refund will be issued.
The copyright of the Components and Templates is owned by Tailwind Labs Inc. You are granted only the permissions described in this license; all other rights are reserved. Tailwind Labs Inc. reserves the right to pursue legal remedies for any unauthorized use of the Components or Templates outside the scope of this license.
Tailwind Labs Inc.’s liability to you for costs, damages, or other losses arising from your use of the Components or Templates — including third-party claims against you — is limited to a refund of your license fee. Tailwind Labs Inc. may not be held liable for any consequential damages related to your use of the Components or Templates.
This Agreement is governed by the laws of the Province of Ontario and the applicable laws of Canada. Legal proceedings related to this Agreement may only be brought in the courts of Ontario. You agree to service of process at the e-mail address on your original order.
Unsure which license you need, or unsure if your use case is covered by our licenses?
Email us at [email protected] with your questions.
Last Modification : 22/06/2025
Luxoria is committed to open-source development, fostering innovation, and enabling collaboration within the developer community. After careful consideration, we have chosen the Apache License 2.0 for our repositories due to its balance of permissiveness, protection, and clarity.
Apache 2.0 is a permissive open-source license that allows anyone to freely use, modify, and distribute our code. This means individuals and businesses can adopt Luxoria's technologies without worrying about restrictive obligations, making it easier for our software to be widely used and integrated.
A major advantage of Apache 2.0 over some other permissive licenses (such as MIT or BSD) is its explicit grant of patent rights. Contributors automatically grant a license to any patents they hold related to their contributions, which reduces the risk of patent litigation and provides more legal certainty for users of our software.
By using Apache 2.0, we ensure that both contributors and users are protected from unexpected legal complications. The license includes:
A patent grant ensuring that contributors cannot later sue users for patent infringement based on their contributions.
A liability disclaimer, protecting both Luxoria and contributors from legal claims arising from the use of the software.
Since Apache 2.0 does not impose copyleft requirements (unlike the GPL), developers and businesses can confidently contribute to Luxoria's repositories without concerns about needing to open-source their proprietary software that incorporates our code.
Apache 2.0 is a widely adopted and trusted license in the open-source community. Many large-scale projects, such as Kubernetes, TensorFlow, and Apache Software Foundation projects, use this license, which ensures familiarity and trust among developers and businesses.
Choosing the right open-source license is crucial for defining how a project can be used and shared. Here’s a quick comparison of Apache 2.0 with other common open-source licenses:
The Apache License 2.0 aligns with Luxoria’s goals of fostering innovation, collaboration, and broad adoption of our open-source software. Its permissiveness, strong patent protections, and business-friendly terms make it the ideal choice for our repositories.
By choosing Apache 2.0, we empower developers while ensuring that both contributors and users benefit from a legally sound and transparent licensing framework.
Luxoria aims to become a modular and extensible platform, enabling a community of users, contributors, and partners to evolve alongside the project. The use of a permissive license like Apache 2.0 facilitates:
Integration into proprietary or commercial products.
Collaboration with companies that may not wish to open-source their enhancements.
Development of an ecosystem around the project, including plugins, modules, and third-party services.
Apache 2.0 is internationally recognized and offers substantial legal clarity, notably through:
Explicit and detailed wording that is understandable to legal teams.
Compatibility with diverse legal frameworks (Europe, North America, etc.).
Clear management of contributions and associated rights, essential for a multi-contributor project.
The choice of license influences project governance. By opting for Apache 2.0, Luxoria:
Avoids debates or friction related to copyleft (often perceived as restrictive).
Encourages diverse contributions (code, documentation, plugins) without legal barriers.
Retains the option to adopt a Contributor License Agreement (CLA) if needed in the future.
We have reviewed the practices of similar projects (e.g., Next.js, Vite, Strapi):
Many use permissive licenses like MIT or Apache 2.0.
Developer feedback indicates that freedom of use without constraints is a key factor for adoption.
The choice of Apache 2.0 aligns with this community-driven logic.
Before finalizing our decision, we evaluated several alternatives:
GPLv3: Rejected for its "viral" effect, which is incompatible with our goal of broad distribution, including in closed environments.
MIT: Too brief and lacks an explicit patent grant—posing a significant risk for technological innovation.
MPL 2.0: Offers a middle ground but is more complex to understand for some contributors.
For more details on the Apache License 2.0, see: https://www.apache.org/licenses/LICENSE-2.0
.NET 8
PostgreSQL
Docker (min. 27.4.0) (optionnel pour déploiement)
Docker Compose (optionnel pour déploiement)
Crée un fichier .env à la racine du projet et ajoute :
Hub Address: /hubs/chat
SendMessage(collectionId, senderEmail, message) → Envoie un message à tous les clients du groupe
JoinCollection(collectionId) → Rejoint un groupe SignalR pour une collection
LeaveCollection(collectionId) → Quitte un groupe SignalR
📌
📌
Swagger UI est disponible à l'adresse : 📌
This document describes the various events used in the Luxoria.Modules.Models.Events namespace, their purpose, and technical details.
FilterCatalogEvent - Requests and retrieves a list of available filters.
CollectionUpdatedEvent - Notifies when a collection has been updated.
LogEvent - Sends a log message to the logging system.
RequestWindowHandleEvent - Requests the native window handle.
TextInputEvent - Sends a text input event.
The FilterCatalogEvent is used to request and retrieve a list of available filters asynchronously.
Namespace: Luxoria.Modules.Models.Events
Implements: IEvent
Response Handling: Uses TaskCompletionSource<List<(string Name, string Description, string Version)>> to handle asynchronous responses.
A component publishes the event.
A subscriber (e.g., a filter manager) listens and provides the filter list.
The event’s TaskCompletionSource is completed with the filter list.
The publisher receives the list.
The CollectionUpdatedEvent notifies subscribers when a collection has been updated.
Namespace: Luxoria.Modules.Models.Events
Implements: IEvent
Properties:
A module publishes this event after updating a collection.
Subscribers (e.g., UI components) react to the update.
The LogEvent is used to send log messages for debugging or monitoring purposes.
Namespace: Luxoria.Modules.Models.Events
Implements: IEvent
Properties:
Any component can publish this event to log information.
A logger service listens for this event and processes the message.
The RequestWindowHandleEvent allows a component to request the native window handle.
Namespace: Luxoria.Modules.Models.Events
Implements: IEvent
Properties:
A component publishes this event with a callback.
A subscriber (e.g., the main window) calls the callback with the window handle.
The TextInputEvent is used to transmit a text input from one component to another.
Namespace: Luxoria.Modules.Models.Events
Implements: IEvent
Properties:
A component publishes this event with a text message.
A subscriber processes the text input.
This document outlines the core events used in Luxoria's event-driven architecture. Each event plays a crucial role in communication between components, improving modularity and scalability.
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
Copyright 2024 Luxoria
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
LuxImport is a image collection management system designed for efficient indexing, asset organization, and metadata handling. It provides capabilities for importing, processing, and managing image datasets, making it an ideal solution for large-scale photography and media applications.
LuxImport follows a modular architecture to ensure scalability, maintainability, and high performance. The key components are:
ImportService: Handles the import process, including asset hashing, metadata extraction, and database initialization.
Manifest Repository: Manages the manifest file that keeps track of indexed assets.
LuxConfig Repository: Stores configuration settings related to collections and assets.
FileHasherService: Computes unique hashes for images to prevent duplication.
Initialization: The system checks whether the target collection exists and initializes it if necessary.
Indexing: Images are scanned, hashed, and added to the database with relevant metadata.
Storage & Retrieval: Indexed assets are stored with reference to their respective manifest files.
Loading Assets: Assets are loaded from storage and processed based on application requirements.
.NET 9: Primary Framework.
BenchmarkDotNet: Used for performance benchmarking.
System.Threading.Tasks: Ensures efficient async processing.
Concurrent Collections: Optimizes parallel data processing.
LuxImport includes a robust testing strategy to ensure stability and correctness.
Covers core functionalities such as:
Initialization of import service.
Manifest file creation and retrieval.
File hashing and metadata extraction.
Verifies the interaction between different modules.
Tests how the ImportService handles large datasets.
Uses BenchmarkDotNet to measure execution time, memory allocation, and threading behavior.
Ensures that asset indexing, loading, and retrieval are optimized for large datasets.
Ensures stability with:
Empty folders
Corrupt image files
Large-scale imports
Performance is a key focus of LuxImport. The system is benchmarked to analyze indexing and retrieval efficiency.
Uses BenchmarkDotNet to measure:
Execution time per operation.
Memory allocations and garbage collection pressure.
Threading efficiency and lock contention.
Initialization: Measures the time required to set up a new collection.
Indexing: Evaluates performance when scanning and hashing assets.
Database Operations: Tests manifest file read/write performance.
Asset Loading: Benchmarks retrieval times for indexed images.
Result is in microseconds (μs).
You can find detailed benchmark results in the LuxImport.Benchmark/BenchmarkDotNet.Artifacts folder.
The provided benchmark results are for reference only and may vary based on the system configuration.
It has been tested on an Apple Silicon M2 chip on Parallels Desktop.
With 3 different collections, 50, 100, and 200 images, the benchmark results are as follows:
Go to the for more details.
The Standard Export Module
Multi-Format Output Export photos in JPEG, PNG, BMP, GIF, WebP, AVIF, TIFF, and more.
Flexible Export Destinations Choose between Hard Drive and Web export modes, each with tailored options.
Custom File Naming
Define filename patterns with dynamic tags like {name}, {date}, {counter}, and metadata fields. Preview filenames instantly before export.
Conflict Handling Decide how existing files are managed: Overwrite, Rename, or Skip.
Subfolder Support Automatically organize exports into subfolders for cleaner project structure.
Advanced File Settings Adjust format, quality, color space (sRGB, etc.), and optional file size limits for precision control.
Watermarking (Web Export) Add text watermarks with adjustable opacity for branding and content protection.
Presets for Reuse Save and load export presets to streamline repetitive workflows.
Real-Time Progress Feedback Track export progress, with the ability to pause or cancel tasks safely.
Select Destination Choose Hard Drive or Web export mode.
Configure Settings Set format, quality, naming pattern, subfolders, and watermark (if applicable).
Preview & Confirm View sample filenames and confirm settings before export.
Export Run the export with live progress tracking and conflict resolution.
Batch Export Reports Generate logs and summaries of exported files for documentation.
Enhanced Metadata Tokens More dynamic options for filename generation.
Branding Templates Predefined watermark and naming schemes for professional delivery.
Luxoria and all standard modules are licensed under the Apache 2.0 License.
See the for details.
Source Code:
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/BSD (3-Clause)
Permissive
No
No
Similar to MIT, with an added clause preventing use of the project’s name
GPLv3
Copyleft
Yes
Yes
Requires derivative works to be open-source, limiting proprietary use
LGPLv3
Weak Copyleft
Yes
Partial
Less restrictive than GPL, but still requires some source disclosure
Apache 2.0
Permissive
Yes
No
Strong legal protection, business-friendly
MIT
Permissive
No
No
Simple and permissive, but lacks patent protection
SkiaSharp Integration: Used for image processing, including metadata extraction and transformations.
SkiaSharp: Handles image processing operations such as metadata extraction and transformations.
Uses xUnit for testing.
Language: C#
Framework: WinUI 3 with .NET 9
IDE: Visual Studio 2022 / Rider
Version Control: Git
CI/CD: GitHub Actions
Deployment: .MSIX
Testing: xUnit
Luxoria Desktop is structured as follows:
Luxoria.App: Main project containing the primary application logic.
Luxoria.Desktop.Tests: Unit tests for ensuring application stability and correctness.
Luxoria.Core: Provides fundamental services, repositories, and models essential for the application.
Luxoria.Modules: Manages modular components of the application, including models, interfaces, and services.
Luxoria.SDK: Houses shared utilities, services, and interfaces to ensure consistency across modules.
Technologies: WinUI 3 with .NET 9
Target SDK Version: net9.0-windows10.0.26100.0
Minimum Platform Version: 10.0.17763.0
Windows SDK Package Version: 10.0.26100.57
Main Entry Point: App.xaml / App.xaml.cs
The application follows a modular architecture where each module is a separate project within the solution, responsible for specific features or functionality.
Technologies: .NET 9.0
Target Framework: net9.0
Functionality: Contains core services, repositories, and models used across the application.
Technologies: .NET 9.0
Target Framework: net9.0
Functionality: Manages modules within the application, ensuring modularization and scalability.
Each module is developed as a separate project to provide distinct functionalities while maintaining interoperability.
Luxoria.SDK provides essential utilities, interfaces, and services to ensure consistency across Luxoria modules. It standardizes logging, file hashing, and module communication, promoting reusability and efficiency.
Interfaces
IFileHasherService: Defines contract for file hashing operations.
ILoggerService: Provides structured logging capabilities.
ILogTarget: Specifies logging targets for various outputs.
Models
LogLevel: Defines log severity levels for structured logging.
Services
FileHashService: Implements file hashing with multiple algorithms.
LoggerService: Provides system-wide and module-specific logging.
Code Reusability: Centralizes common functionalities across modules.
Scalability: Easily extensible for new services and features.
Consistency: Ensures uniformity in logging, file management, and cross-module communication.
Luxoria Standard Modules (LuxStd Modules) provide core functionalities within the Luxoria ecosystem. They follow a standardized architecture, ensuring seamless integration, extensibility, and interoperability.
Modular Design: Follows a plug-and-play structure.
Event-Driven: Utilizes IEventBus for module communication.
Extensible: Allows enhancement without breaking compatibility.
Asynchronous Processing: Optimized for high-performance and non-blocking operations.
Structured Logging & Error Handling: Implements ILoggerService for debugging and diagnostics.
Manages importation, indexing, and organization of digital asset collections.
Processes large datasets with asynchronous operations and real-time progress tracking.
Provides an advanced filtering pipeline for processing and scoring digital assets.
Implements a modular filtering framework with weighted execution for improved accuracy.
Luxoria Desktop follows a modular architecture, ensuring scalability, maintainability, and high performance. LuxStd Modules serve as the foundation of the ecosystem, providing essential functionalities in an event-driven and extensible manner. The inclusion of Luxoria.SDK ensures consistency across different modules, making development more efficient and streamlined.
PATCH
/api/collection/{collectionId}/allowedEmails
Met à jour les emails autorisés dans la collection
DELETE
/api/collection/{id}
Supprime une collection par ID
POST
/api/collection/{collectionId}/upload
Télécharge des fichiers pour une collection
POST
/api/collection/{collectionId}/chat
Ajoute un message au chat d'une collection
POST
/api/auth/login
Authentifie un utilisateur et retourne un JWT
POST
/api/auth/register
Crée un nouvel utilisateur
GET
/api/collection
Récupère toutes les collections
GET
/api/collection/{id}
Récupère une collection par ID
POST
/api/collection
Crée une nouvelle collection
PUT
/api/collection/{id}
Met à jour une collection par ID
CollectionName (string) - The name of the updated collection.CollectionPath (string) - The file path of the collection.
Assets (ICollection) - The updated assets in the collection.
Message (string) - The log message.OnHandleReceived (Action) - Callback to return the window handle.Text (string) - The text input.Validation: Ensures the text is not null or empty.
Multi-format export support using SkiaSharp
Customizable file naming with pattern-based presets
Conflict resolution options: overwrite, rename, skip
Support for subfolder creation and base path selection
Live progress display during export operations
Modular design and integration with IEventBus
Implements IModule and IModuleUI
Handles initialization and shutdown
Subscribes to CollectionUpdatedEvent
Instantiates and controls the main Export dialog
ViewModel for binding export settings to the UI
Manages file naming, export paths, format settings, and presets
Static factory that returns an IExporter implementation based on ExportFormat
Supports JPEG, PNG, BMP, GIF, WEBP, AVIF, and many others
UI window that displays export progress
Handles exporting on a background thread
Provides preview and pause/cancel support
Resolves tags in naming patterns like {name}, {date}, {counter}, and meta: keys
Allows dynamic generation of file names
Ensure that the Luxoria ecosystem is installed and configured
Register the module via your main application’s module loader
Implement and provide IEventBus, IModuleContext, and ILoggerService
Add the LuxExport module to your Luxoria project.
Connect the module to the UI via smart button configuration.
Load file naming presets from a JSON file.
Call Initialize() with required dependencies.
Trigger Export via UI interaction.
Choose export location, format, and file naming options.
Launch export via the main button.
View progress in the export window.
Subscribes to CollectionUpdatedEvent
Registers UI components
Sets up Export dialog
Receives image data and metadata from CollectionUpdatedEvent
Calls SetBitmaps(...) on the export dialog
Users select format, color space, quality
Optionally define size limit and subfolder behavior
Supports dynamic patterns like {name}_{date}
Applies extension casing and resolves conflicts
Uses ExporterFactory to get exporter instance
Applies settings and writes to disk (or simulated web)
Displays progress bar and image preview
Receives the updated list of assets
Extracts SKBitmap and metadata
Passes them to Export dialog
Uses ILoggerService for structured logging
Exceptions during export are caught and logged
Displays error messages in the progress window if needed
Export runs on a background thread using Task.Run
UI updates dispatched via DispatcherQueue
SkiaSharp is used for efficient image encoding
Export presets based on project type
Metadata filtering before export
Batch export reports generation
LuxExport provides a flexible and user-friendly way to export images in the Luxoria ecosystem. Its modular structure and advanced export options make it a powerful tool for end-users and developers alike.
Last updated: April 2025
git clone https://github.com/ton-repo/LuxAPI.git
cd LuxAPIConnectionStrings__DefaultConnection=Host=localhost;Port=5432;Database=LuxDB;Username=postgres;Password=yourpassword
Jwt__Key=your-secret-key
Jwt__Issuer=https://your-api.com
Jwt__Audience=https://your-api.com
Minio__Endpoint=http://localhost:9000
Minio__AccessKey=your-access-key
Minio__SecretKey=your-secret-keydotnet restoredotnet ef database updatedotnet rundocker-compose up --buildvar filterEvent = new FilterCatalogEvent();
await _eventBus.Publish(filterEvent);
var receivedFilters = await filterEvent.Response.Task;var updateEvent = new CollectionUpdatedEvent("MyCollection", "/path/to/collection", assets);
_eventBus.Publish(updateEvent);_eventBus.Publish(new LogEvent("This is a log message."));var requestEvent = new RequestWindowHandleEvent(handle => Debug.WriteLine($"Handle: {handle}"));
_eventBus.Publish(requestEvent);_eventBus.Publish(new TextInputEvent("User input text")); To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives. http://www.apache.org/licenses/LICENSE-2.0var luxExport = new LuxExport();
luxExport.Initialize(eventBus, context, logger);
luxExport.Execute();public void Initialize(IEventBus eventBus, IModuleContext context, ILoggerService logger)_eventBus.Subscribe<CollectionUpdatedEvent>(OnCollectionUpdated);Last Updated: 01/06/2025
In modern application development, selecting the right dependencies is crucial to ensuring performance, reliability, and maintainability. This document outlines the rationale behind the inclusion of SkiaSharp 3.116.1, Luxoria.Algorithm.BrisqueScore (OpenCV 4.10.0 / C++23), and Sentry SDK in our WinUI 3-based application, providing justifications supported by industry standards and research.
SkiaSharp is a cross-platform 2D graphics library built on Google’s Skia graphics engine, widely adopted in Chrome, Android, and Flutter. It enables high-quality rendering, text shaping, and image processing, making it an essential component for modern UI development.
High-Performance Rendering SkiaSharp supports GPU acceleration and hardware-based optimizations, significantly enhancing real-time rendering performance. Google's documentation states that Skia outperforms software rasterization, making it a preferred choice for applications requiring smooth rendering ().
Advanced Drawing Capabilities SkiaSharp provides anti-aliasing, vector graphics, complex path rendering, and blending modes, surpassing WinUI 3’s default rendering capabilities. These features enable the creation of visually compelling and interactive applications ().
Cross-Platform Consistency Ensures that graphics rendering remains uniform across Windows, macOS, Linux, iOS, and Android, making it future-proof for cross-platform expansion ().
The Blind/Referenceless Image Spatial Quality Evaluator (BRISQUE) is a state-of-the-art image quality assessment algorithm that quantifies the perceptual quality of images without requiring a reference image (). OpenCV 4.10.0, optimized with C++23, provides a high-performance computing framework for implementing BRISQUE in real-time applications.
Easy-to-Use .NET API The Luxoria.Algorithm.BrisqueScore package provides a .NET wrapper around the BRISQUE algorithm, making it accessible for .NET applications. It enables developers to compute image quality scores without a reference image.
Cross-Platform Support The package includes precompiled native libraries for x86, x64, and arm64, ensuring compatibility across a wide range of Windows devices.
Efficient Image Quality Analysis BRISQUE extracts spatial features and computes perceptual quality scores, making it ideal for automated and real-time quality assessment in photography, medical imaging, and security applications ().
Sentry is an industry-leading real-time error tracking and performance monitoring tool that helps developers detect, diagnose, and fix issues in production environments. It provides deep .NET and C++ integration, making it an essential component for improving the stability and maintainability of WinUI 3 applications.
Automatic Error Tracking Sentry captures unhandled exceptions, crashes, and memory leaks in real-time, allowing developers to proactively address issues ().
Real-Time Alerts & Monitoring Supports configurable alerting for slow response times, crashes, and memory leaks, ensuring high application availability.
Contextual Debugging Sentry logs stack traces, breadcrumbs, and system states, providing developers with the full execution context at the time of failure ().
By integrating SkiaSharp, Luxoria.Algorithm.BrisqueScore (OpenCV 4.10.0 / C++23), and Sentry SDK, we ensure that our WinUI 3 application is highly performant, visually compelling, and robust in production environments.
SkiaSharp enables smooth, high-quality UI rendering, enhancing user experience.
Luxoria.Algorithm.BrisqueScore provides advanced image analysis and processing capabilities for vision-based applications.
Sentry SDK ensures application stability, reliability, and proactive debugging.
This technology stack enables us to build scalable, performant, and visually appealing applications that stand out in both functionality and user experience.
Seamless Integration with WinUI 3 Supports .NET 9 and WinUI 3, making it a natural choice for modern Windows applications. It enables developers to implement rich graphical interfaces while maintaining high performance.
Optimized Memory Management Unlike GDI+ or Direct2D, SkiaSharp employs hardware-accelerated rendering techniques that reduce CPU and memory consumption, improving application efficiency and reducing power consumption (Google Skia).
Custom Font & Text Shaping SkiaSharp includes Harfbuzz for text shaping, allowing precise typography rendering, including international scripts (Harfbuzz Project).
Resizing Performance Comparaison & Benchamarks available at : https://anthonysimmon.com/benchmarking-dotnet-libraries-for-image-resizing/
Optimized for Modern Hardware OpenCV 4.10.0 leverages SIMD optimizations, AI-assisted vision processing, and GPU acceleration, offering substantial performance gains over previous versions. C++23 further improves efficiency with enhanced multi-threading and memory management features (ISO C++23).
Seamless Interoperability with .NET and WinUI 3 Through P/Invoke, C++/CLI, and WinRT, OpenCV integrates seamlessly with .NET-based applications, allowing for high-performance real-time image processing within WinUI 3 (Microsoft Interop Guide).
Extensive Image Processing Features OpenCV provides a comprehensive set of tools for edge detection, noise reduction, object recognition, and image enhancement, essential for automated photography and visual quality control applications (MIT Computer Vision Lab).
Cloud-Based or Self-Hosted Flexibility Developers can choose between SaaS-based hosting for scalability or self-hosted solutions for enterprise security.
Performance Monitoring & Distributed Tracing Tracks slow function executions, API latency, and database queries, ensuring a smooth user experience (Google Web Performance Guide).
The purpose of this testing policy is to establish a clear and robust framework for writing, organizing, and maintaining unit tests for the Luxoria project. This ensures consistent quality, high coverage, and minimal regressions throughout development.
Please refer to Luxoria UI Manual Test Protocol, to test / assert our Luxoria Desktop Application
High Coverage:
Ensure all critical components and workflows are covered, including normal, edge, and error scenarios.
Test Isolation:
Each unit test must run independently of others. External dependencies must be mocked or stubbed.
Tests should mirror the structure of the source code:
Luxoria.Modules → Luxoria.Modules.Tests
Each class or module should have a dedicated test file named ClassNameTests.cs.
Tests should clearly describe their intent using the format:
MethodName_StateUnderTest_ExpectedBehavior
Example: Subscribe_WithValidHandler_ShouldAddSubscriber
Tests must cover:
Standard Cases: Typical input and expected behavior.
Edge Cases: Extreme conditions such as null values, empty lists, or large inputs.
Error Cases: Behavior when exceptions are expected or invalid data is provided.
Use mocking libraries (e.g., Moq) to isolate dependencies.
Verify mock interactions to ensure proper communication between components.
Common dependencies should be initialized in a shared setup method (e.g., constructors or [SetUp] in test frameworks).
Assertions must be explicit and descriptive to validate expected outcomes:
Use Assert.Equal, Assert.NotNull, and Mock.Verify for clarity.
Write tests before implementing the functionality to capture business requirements effectively.
Ensure error handling paths are tested. For example:
Validate proper exceptions are thrown for invalid inputs.
Test fallback mechanisms where applicable.
A unit test file should follow this basic structure:
Use CI tools (e.g., GitHub Actions, Jenkins) to run unit tests automatically on every commit.
Track test coverage metrics using tools like coverlet or dotCover.
Set thresholds for coverage to prevent regressions (e.g., 80% minimum).
Code Reviews:
All new test code must be reviewed by peers to ensure adherence to this policy.
Test Audits:
Conduct periodic reviews to identify outdated or redundant tests and improve overall coverage.
Track the following metrics to ensure test quality:
Test Coverage: Percentage of code covered by tests.
Test Reliability: Percentage of flaky or unreliable tests.
Execution Time: Average time taken for tests to run.
This policy ensures consistency and scalability for the testing practices in Luxoria. With proper adherence, it will facilitate long-term project stability and maintainability.




Performance:
Tests should execute quickly to support continuous testing during development.
Readability:
Test code should be self-explanatory, with clear naming conventions and comments where needed.
Ease of Maintenance:
Tests must be straightforward to update as the code evolves. Avoid excessive coupling between tests and implementation details.
Refactoring:
Update tests whenever code is refactored to align with new implementations.
212.5 μs
2.50 μs
2.34 μs
212.7 μs
-
-
-
-
-
544 B
BenchmarkInitializeDatabase
\Mac\(...)t_200 [31]
222.3 μs
1.69 μs
1.41 μs
221.9 μs
-
-
-
-
-
544 B
BenchmarkInitializeDatabase
\Mac\(...)et_50 [30]
221.9 μs
1.64 μs
1.45 μs
221.7 μs
-
-
-
-
-
528 B
BenchmarkIndexCollectionAsync
\Mac\(...)t_100 [31]
363,789.4 μs
7,220.64 μs
10,355.63 μs
362,619.7 μs
1.0000
-
-
-
-
835440 B
BenchmarkIndexCollectionAsync
\Mac\(...)t_200 [31]
401,680.5 μs
8,007.05 μs
19,940.34 μs
404,522.2 μs
1.0000
-
-
-
-
835440 B
BenchmarkIndexCollectionAsync
\Mac\(...)et_50 [30]
392,667.6 μs
7,837.67 μs
12,656.39 μs
391,574.4 μs
1.0000
-
-
-
-
872432 B
BenchmarkIsInitialized
\Mac\(...)t_100 [31]
216.9 μs
4.15 μs
3.88 μs
215.5 μs
-
-
-
-
-
544 B
BenchmarkIsInitialized
\Mac\(...)t_200 [31]
215.8 μs
2.21 μs
1.85 μs
215.7 μs
-
-
-
-
-
544 B
BenchmarkIsInitialized
\Mac\(...)et_50 [30]
218.9 μs
4.38 μs
6.14 μs
216.2 μs
-
-
-
-
-
528 B
BenchmarkLoadAssets
\Mac\(...)t_100 [31]
2,746,052.2 μs
115,195.76 μs
330,518.24 μs
2,627,569.7 μs
140.0000
-
8000.0000
7000.0000
5000.0000
46234408 B
BenchmarkLoadAssets
\Mac\(...)t_200 [31]
2,688,051.4 μs
100,639.20 μs
282,203.13 μs
2,655,953.1 μs
134.0000
1.0000
10000.0000
8000.0000
7000.0000
46710912 B
BenchmarkLoadAssets
\Mac\(...)et_50 [30]
2,843,692.2 μs
100,855.93 μs
274,386.03 μs
2,781,623.8 μs
132.0000
-
8000.0000
7000.0000
4000.0000
46168160 B
BenchmarkInitializeDatabase
\Mac\(...)t_100 [31]
using Xunit;
using Moq;
using Luxoria.Modules;
namespace Luxoria.Modules.Tests
{
public class ClassNameTests
{
private readonly ClassName _classUnderTest;
public ClassNameTests()
{
_classUnderTest = new ClassName();
}
[Fact]
public void MethodName_StateUnderTest_ExpectedBehavior()
{
// Arrange
var mockDependency = new Mock<IDependency>();
// Set up dependencies
// Act
var result = _classUnderTest.MethodUnderTest();
// Assert
Assert.NotNull(result);
}
}
}[Fact]
public void Subscribe_NullSubscriber_ShouldThrowArgumentNullException()
{
// Arrange
Action<LogEvent> nullSubscriber = null;
// Act & Assert
Assert.Throws<ArgumentNullException>(() => _eventBus.Subscribe(nullSubscriber));
}[Fact]
public void Unsubscribe_NonexistentSubscriber_ShouldNotThrow()
{
// Arrange
var mockSubscriber = new Mock<Action<LogEvent>>();
// Act & Assert
_eventBus.Unsubscribe(mockSubscriber.Object); // Should not throw
}
BenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4751/23H2/2023Update/SunValley3)
Apple Silicon, 6 CPU, 6 logical and 6 physical cores
.NET SDK 9.0.102
[Host] : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD
DefaultJob : .NET 9.0.1 (9.0.124.61010), Arm64 RyuJIT AdvSIMD


Last Updated: 01/06/2025
WinUI 3 with .NET 9.0 is a modern UI framework developed by Microsoft, designed for building high-performance, native Windows applications. It is the evolution of UWP and WPF, offering a more advanced and optimized approach to Windows app development. This document provides an extensive comparison of WinUI 3 with alternative solutions, including WPF, Electron.js, JavaFX, and Qt, focusing on their strengths, weaknesses, and best use cases.
WinUI 3 is also built with modularity in mind, allowing developers to create applications that are scalable, maintainable, and easy to integrate with other Windows and .NET components. The separation of UI and business logic is enhanced through MVVM (Model-View-ViewModel) support, ensuring better maintainability and testability.
WinUI 3 is designed to offer a seamless experience for Windows developers. It allows deep integration with Windows APIs, providing a native feel and optimized performance. Unlike WPF, which relies on older DirectX 9 technology, WinUI 3 is built on DirectX 12, enabling more efficient rendering, smoother animations, and better resource utilization.
Modern Fluent Design System for sleek and responsive UI
Hardware-accelerated graphics powered by DirectX 12
Deep integration with Windows APIs, ensuring robust system interactions
Full support for .NET 9.0, providing improved performance and maintainability
Uses DirectX 12, offering faster, smoother graphics rendering
Built-in support for modern Fluent UI, making applications visually appealing
Better long-term support from Microsoft, as WPF is in maintenance mode
More optimized memory usage, resulting in improved performance on low-resource systems
Works on Windows 7, 8, and 10, while WinUI 3 is Windows 10/11 only
More established ecosystem with extensive documentation and community support
Better suited for legacy applications that need to maintain compatibility with older systems
Supports WinForms integration
Uses native Windows APIs, ensuring superior performance compared to Electron’s web-based rendering
Lower memory footprint, as Electron runs a full Chromium instance for every app
Better modularity, allowing developers to optimize individual components without overhead
More seamless OS integration, allowing direct access to Windows features like system tray, notifications, and file management
Cross-platform compatibility (Windows, macOS, Linux)
Leverages web development skills, making it more accessible for developers coming from web backgrounds
Large ecosystem of JavaScript libraries and frameworks
Faster prototyping, as it allows rapid UI development with web tools
Better performance, as JavaFX relies on OpenGL and Swing is outdated
Easier access to Windows system APIs, allowing for deeper system integration
More modern UI components, enhancing user experience
More energy-efficient, reducing CPU usage compared to Java-based solutions
Cross-platform support, running on Windows, macOS, and Linux
Good choice for Java-based enterprise applications, particularly those that already leverage Java backend systems
Strong JVM ecosystem, making it an attractive option for Java developers
Better Windows integration, ensuring native Windows UI and behavior
More accessible to .NET developers, making it a better choice for those already using Microsoft technologies
No licensing costs, making it a more affordable option for businesses and developers compared to Qt, which requires commercial licenses for enterprise use. Open-source adoption is encouraged, allowing for widespread use without financial constraints. Additionally, WinUI 3 benefits from Microsoft's ecosystem, ensuring continuous updates and support.
Cross-platform compatibility (Windows, Linux, macOS, iOS, Android)
Superior performance for CPU-intensive applications, as it is built in C++
More established for industrial applications, particularly in fields like automotive and medical software
WinUI 3 with .NET 9.0 emerges as the best choice for building modern Windows applications. With its high performance, deep Windows integration, modularity, and modern Fluent UI, it provides a superior alternative to older frameworks like WPF and JavaFX.
While WPF remains relevant for legacy applications, its maintenance mode status makes it a less viable option for future-proof development. Electron.js is ideal for web developers looking to create cross-platform applications but suffers from high memory usage and security concerns. JavaFX and Swing are better suited for Java-based projects, though they lack modern UI capabilities. Qt remains a strong contender for cross-platform development, particularly in performance-intensive applications.
For Windows-first applications requiring a modern UI, modularity, and superior performance, WinUI 3 with .NET 9.0 is the best option. However, if cross-platform support is a strict requirement, Qt or Electron.js might be preferable, depending on the specific needs of the application.
Version 1.0 Last Updated: 01/02/2025
The choice of technologies for the frontend and security is based on several criteria: performance, maintainability, user experience, and ease of integration with the backend.
For this project, we opted for Vue.js + TypeScript with DaisyUI and TailwindCSS for styling. Additionally, hCaptcha was chosen for security, ensuring protection against automated threats while maintaining user privacy. This section outlines the reasons for these choices and compares them with other popular solutions.
Vue.js is a progressive JavaScript framework that enables the creation of interactive user interfaces with a gentler learning curve compared to its competitors. It offers a modular and reactive approach, making modern frontend development easier.
Simplicity and flexibility: A clear and easy-to-learn syntax.
Reactivity: The built-in reactivity system allows smooth state management.
Rich ecosystem: Vue Router for navigation, Pinia/Vuex for state management.
Performance: Better DOM optimization than React due to its lightweight Virtual DOM.
TypeScript adds static typing to JavaScript, improving code robustness and maintainability.
Detects errors at compilation, reducing bugs in production.
Enhances auto-completion and developer experience.
Better code documentation through explicit types.
TailwindCSS is a utility-first CSS framework that enables the creation of well-styled interfaces without excessive custom CSS.
Increased productivity: Styles applied directly in HTML, reducing the need for custom CSS.
Optimized performance: Purgeable CSS, loading only what is used.
Easy customization: Configurable via tailwind.config.js.
DaisyUI is an extension of TailwindCSS that provides pre-designed components following Material Design and Fluent Design principles.
Time-saving: Ready-to-use UI components.
Predefined themes: Easily adaptable to project needs.
Seamless integration: Works directly with TailwindCSS.
hCaptcha is a security tool designed to protect websites from bots, spam, and other automated threats while respecting user privacy. It offers an alternative to Google's reCAPTCHA, prioritizing decentralization and compliance with data privacy regulations.
Better privacy: Does not track users across websites, ensuring GDPR and CCPA compliance.
Higher accuracy: Uses advanced machine learning to detect bots more efficiently.
More control: Website owners can monetize CAPTCHA challenges while protecting their site.
Lightweight and efficient: Provides security without significant performance overhead.
Choosing Vue.js with TypeScript provides an excellent balance between simplicity, performance, and maintainability. Combined with TailwindCSS and DaisyUI, it enables fast development with a modern and optimized UI.
For larger and more structured applications, Angular can be an option, while React is a good choice for applications requiring a mature ecosystem and strong community support. However, Vue.js remains more accessible and offers better productivity for this project.
For security, hCaptcha stands out as a privacy-friendly and efficient alternative to Google’s reCAPTCHA, ensuring robust protection without compromising user data. It is particularly suitable for projects requiring GDPR compliance and enhanced privacy control.
Version 1.0 Last Updated: 01/02/2025
The backend is the backbone of any web application, responsible for handling business logic, data management, security, and API integrations. For this project, we chose .NET WebAPI (NET 8) as the core backend technology.
This section outlines the reasons behind this choice and compares it with other backend solutions like Node.js, Django, and Spring Boot.
.NET WebAPI is a robust framework developed by Microsoft for building RESTful web services. It offers excellent performance, scalability, and security, making it an ideal choice for modern web applications.
High performance: Optimized with Just-In-Time (JIT) and Ahead-Of-Time (AOT) compilation.
Scalability: Supports microservices architecture and cloud-native applications.
Security: Built-in authentication and authorization mechanisms with ASP.NET Identity.
According to TechEmpower Benchmarks (Round 21), .NET ranks among the fastest web frameworks:
.NET → 7.02M requests/sec
Java Servlet → 2.20M requests/sec
Node.js → 0.60M requests/sec
This highlights the superior performance of .NET WebAPI compared to popular alternatives. (Source: )
Minimal APIs: Simplified route handling for lightweight applications.
Improved performance: Faster execution with native AOT compilation.
Dependency Injection (DI): Built-in DI system for managing dependencies efficiently.
gRPC Support
.NET WebAPI (NET 8) is an excellent choice for backend development due to its high performance, security, and scalability. It offers seamless integration with databases, frontend frameworks, and cloud services, making it an ideal solution for modern web applications.
While Node.js is a good option for lightweight, event-driven applications, and Django is preferred for Python-based projects, .NET WebAPI stands out in terms of raw performance, security, and enterprise-grade features.
For large-scale applications, Spring Boot remains a strong competitor, but .NET WebAPI provides a more modern and optimized development experience.
Version 1.0 Last Updated: 01/02/2025
Efficient data storage is a crucial component of any web application, ensuring reliable and scalable data management. For this project, we opted for PostgreSQL as the database and Entity Framework (EF) Core as the Object-Relational Mapper (ORM).
This section explains the reasons for these choices and compares them with alternative database and ORM solutions.
PostgreSQL is an advanced open-source relational database management system (RDBMS) known for its robustness, performance, and extensibility. It is widely used in enterprise applications and supports both SQL and NoSQL features.
ACID compliance: Ensures data integrity and reliability.
Scalability: Efficient handling of large datasets and concurrent users.
Extensibility: Supports custom functions, JSONB storage, and full-text search.
Security: Strong authentication mechanisms, encryption, and role-based access control.
According to PostgreSQL benchmarks:
PostgreSQL 11 vs MongoDB 4.0: PostgreSQL achieved higher throughput, ranging from several percentage points up to one or two orders of magnitude in certain tests ().
Performance evolution: Tests using pgbench from PostgreSQL 9.6 to 15 showed substantial transaction processing improvements ().
Entity Framework Core is a lightweight, extensible, and high-performance ORM for .NET applications. It simplifies database interactions by allowing developers to work with data using C# objects instead of raw SQL queries.
Productivity: Reduces boilerplate code for database interactions.
Cross-platform: Works on Windows, Linux, and macOS.
Migration support: Handles schema evolution with automated database migrations.
Performance optimizations: Includes
PostgreSQL is the ideal database for this project due to its robustness, extensibility, and scalability. It provides excellent performance, strong security, and a wide range of advanced features, making it a preferred choice over MySQL for complex applications.
Entity Framework Core is the best ORM for .NET applications, offering productivity, maintainability, and database-agnostic flexibility. While Dapper provides raw SQL performance, EF Core strikes a balance between efficiency and ease of use, making it the preferred choice for most scenarios.
By combining PostgreSQL and EF Core, we ensure a scalable, efficient, and maintainable storage solution for our application.
Better modularity, allowing developers to structure applications more efficiently
Lower memory consumption compared to web-based solutions like Electron.js
Enhanced security model with built-in sandboxing capabilities
Better debugging and profiling tools with integration into Visual Studio
Support for WinRT and COM interop, making native Windows feature integration seamless
Future-proof Windows development, ensuring compatibility with upcoming OS updates
More modular architecture, making it easier to update and maintain applications
Better integration with .NET ecosystem, enabling advanced functionality with C# and .NET APIs
Better security, as Electron apps often struggle with vulnerabilities due to their web-based nature
Improved CPU and GPU efficiency, leading to longer battery life on laptops and mobile devices
Better multithreading support, as Electron is limited by JavaScript's single-threaded nature
Better integration with cloud services, leveraging .NET's strong cloud support
Extensive documentation and community support, with Microsoft providing official guides, forums, and tutorials, making it easier for developers to adopt and troubleshoot.
Performance efficiency, leveraging hardware acceleration and DirectX 12 to ensure smooth UI rendering and responsiveness, outperforming frameworks like Electron in resource utilization. as Qt requires commercial licenses for enterprise applications
Better default UI components, reducing the need for extensive UI customization
Better .NET ecosystem compatibility, leveraging features like LINQ, async/await, and dependency injection
Easy integration: Compatible with existing projects and can be gradually adopted.
Integration
Easy for existing projects
Best suited for complex SPAs
Usage
Ideal for dynamic projects
Preferred for enterprise applications
Seamless database integration: Works well with Entity Framework (EF) Core and PostgreSQL.
Cross-platform: Can run on Windows, Linux, and macOS.
Integration with frontend frameworks: Easily integrates with Vue.js, React, and Angular.
Learning Curve
Steeper for beginners
Easier for JavaScript devs
Learning Curve
Moderate
Easier for Python devs
Performance: Optimized query execution and indexing strategies.
Cross-platform support: Runs on Windows, Linux, and macOS.
Database-agnostic: Supports multiple databases, including PostgreSQL, MySQL, and SQL Server.
LINQ support: Enables expressive and strongly-typed queries.
Security
Advanced role-based access
Basic authentication
Use Case
Recommended for large projects
Ideal for micro-optimizations
Privacy
GDPR-compliant, no tracking
Tracks users across websites
Accuracy
High accuracy with ML
Strong but Google-dependent
Monetization
Allows site owners to earn
No earning potential
Performance
Lightweight and fast
Can add extra load to pages
Learning Curve
Easier and more intuitive
More complex, requires JSX
Performance
Optimized Virtual DOM
High-performance Virtual DOM
Ecosystem
Vue Router, Pinia, Vite
Next.js, Redux, Webpack
Model
Options API or Composition API
Hooks and functional components
Complexity
Lightweight and progressive
Full-fledged framework, heavier
Performance
Faster for small projects
Optimized for large applications
Architecture
Flexible, modular
Strict and structured
Learning Curve
Easy to grasp
Complex, requires TypeScript
Performance
High, thanks to compiled C#
Good, but single-threaded
Scalability
Supports multi-threading
Uses event-driven model
Security
Strong built-in security
Requires additional packages
Database
Native support for SQL/NoSQL
Strong MongoDB ecosystem
Performance
High due to compiled C#
Good, but Python overhead
Scalability
Microservices-ready
Better suited for monoliths
Security
Built-in authentication
Strong security features
Database
SQL & NoSQL
SQL-first (PostgreSQL, MySQL)
Performance
Faster due to JIT & AOT
Good, but Java is heavier
Scalability
Microservices-ready
Enterprise-grade scalability
Security
Built-in ASP.NET Identity
Strong security features
Dev Speed
Faster with C# and minimal APIs
Performance
High for complex queries
Faster for read-heavy workloads
Scalability
Excellent for large datasets
Good, but can be limited
ACID Compliance
Fully ACID-compliant
ACID-compliant, but with trade-offs
Extensibility
Supports JSONB, custom types
Limited customizability
Productivity
Higher due to automation
Requires more manual SQL
Performance
Good, but abstraction overhead
Faster for raw SQL queries
Query Flexibility
Uses LINQ, automated queries
Full control over SQL
Learning Curve
Easier for .NET developers
Requires SQL expertise
Requires more boilerplate


Add WindowCaption on MarketplaceView ()
create preset from current settings when expander is false ()
Delete old files before installing new release ()
Enhances layer operation UI in preset editor ()
Smooths histogram data with Gaussian blur ()
Adds animated transitions to histogram ()
Histogram responsiveness ()
Assembly version helper & usage ()
GetVersion returns Version (Version-nullable to Version) ()
GetVersion method (fetches from assembly) ()
Displays version on splash screen ()
Add Assembly helper ()
Add recommended information on version selector ()
Marketplace selects recommended version as default ()
Improves CLIP algo and adds resource handling ()
Improves gradient tool rendering and overlay ()
Improves gradient tool rendering and overlay ()
Improves subject overlay and tool handling ()
Add ApplicationReady event, being published after launching the app ()
Integrate AppVersion on launching splash screen ()
Optimisation of LuxEditor concurrencies ()
Add authorization header to photo fetch requests and handle fetch errors ()
Add debug information when sending mail ()
Add debug information when SendMention ()
Brings authorization in CollectionController ()
Enhance image loading with ProtectedImage component and caching mechanism ()
Implement AdminOnlyFilter and restrict access to admin routes; add 403 Forbidden page ()
Refactor ProtectedImage component for improved image loading and caching ()
Allow failure on module intialisation process ()
Compilation issue when using IStorageAPI (should have required importation of Luxoria.Core) ()
Restore old implementation method for importation (for working with LuxEditor) ()
dpi scale issue ()
Simplifies DPI handling in PhotoViewer ()
Add develop version if app_version is null or not defined ()
Add pre-step for masking the first char (v) of app_version envvar ()
Replace Version by $env:Version ()
Specify AppVersion on msbuild command ()
Add AppVersion environment variable into Luxoria.App.csproj file ()
Missing IStorageAPI interface in Luxoria.Modules namespace ()
Concurrency when import service initialises and loads assets into collection ()
Comment out plan release phase for debugging purpose ()
Add deploy to saturn environment inside CircleCI ()
Add proper kube config for saturn env ()
Remove debug messages ()
Enhances crop editor with aspect ratio controls ()
Add debug message for chat debugging purpose ()
Enable Reflection inside Luxoria.App (fixes bugs on x86 & ARM64) ()
Sliders not sliding smoothly in Layers ()
Specify TypeInfoResolver (fixing crashes on x86) ()
LuxImport's brochure, excluding HTML rendering not supporting by CommunityToolkKit MD renderer ()
Move README.md for both LuxEditor and LuxExport to proper folders ()
Using permalink for displaying PNG inside MD file ()
Add graphical view of LuxFilter UI ()
Enhance brochure of LuxEditor by adding pictures, etc ()
Enhance marketplace installing process with info modal ()
Upload to marketplace python script by specifying branch_src in upload_dirs param list ()
LuxImport brochure's main picture with Github permalink to avoid issue if deleted ()
LuxMarketplace takes a src_branch_name instead of "main" ()
Implements file size optimization for export ()
Presets for web export ()
Enable Flatten when downloads artifacts ()
Necessary env. variable known as GITHUB_TOKEN for retreiving and attaching artifacts ()
Specify artifact list instead of *.exe ()
Include all LuxoriaSetup before zipping the remaining file ()
Upload exe before zipping the remaining part ()
Upload exe as artifacts unzipped (version) ()
Fix names of modules in navigation bar ()
Add app_version input to workflows for versioning ()
Change default version (1.0.0) by specifying 'dev' instead ()
Change platform environment var by using matrix.platform ()
ISCC command only uses a single arg ()
Append installer executable as an artifact ()
Run Inno Wizard on build-upload-lda workflow ()
Image duplicates in collection explorer ()
Add curves to reset default button ()
Add debug configuration of debug/testing environement ()
Add FrontEnd URI inside allowed Origin ()
Adjust mention dropdown width and improve chat input layout ()
Allow access to /config/api route even if the user is not logged in ()
add '/forgot-password' to public paths in middleware for improved access ()
Add authorization checks for collection and photo access in CollectionController ()
add base of LuxStudio V2 ()
add chat functionality for photo comments and implement file download feature ()
Template file location, using vault service. Remove adobe icc color profile. ()
Replace HintPath (static full path) with ProjectRef (dynamic config + path) for LuxStudio.COM ()
Add LuxInstall.iss for x64, x86 and ARM64 ()
Add LuxStudio module configuration file ()
Add Scenario 4 PDF to BTP Scenarios ()
Add issues specifications inside Roadmap ()
Clears filter controls when toggled off ()
Improves sort and filter behavior ()
Adds asset filtering visibility property for export ()
Filtering to collection explorer ()
Add folder for BTP scenario validations ()
Add scenaria 5 ()
Roadmap files (pdf & docx) ()
Roadmap integrates Dependency feature ()
Hides UI elements for web export ()
Enables exporting assets in different formats (for web) ()
Missing image data for chat URL ()
Chat integration in LuxEditor ()
Add details inside Roadmap ()
Add converter for GetApiUrlAsync choosing between LuxPortal v1 / v2 (default set to v2) ()
AuthSrv might be null by modifying the l22 ()
Bring Simplification over Configuration Service ()
Add AuthManager to automaticly handle Token Generation, Login Page, Token renewal, etc. ()
Add check to automatically add "https://" before studio URL ()
Add ExchangeAuthorizationCode method in AuthService (LuxStudio.COM) ()
Add Init AuthManager on LuxStudio/AccManagement part ()
Roadmap 2025-2026 ()
Change GridView for a StackView for visibility purpose ()
Add Blur background effect on LuxEditor @ 2.0.4 ()
Add FlyoutMenu for highlighting ROI, viewing details, removing or applying blur-effect + Installation of Luxoria.Algorithm.GrabCut nuget ()
Add fondation of subject recognition on LuxEditor ()
Add Roadmap PG5 documents in DOCX and PDF formats ()
Add files inside gonogo folder ()
Add documentation and images for contributions ()
Add Epitech BTP file ()
Add files ()
Add License Justification document for Apache 2.0 ()
Crop corner resize while box is rotated ()
Improves crop box clamping logic. ()
Infinite loop on crop changed ()
Photoviewer Canvas Host horizontal and vertical alignment issue, forcing center position ()
Add async fetches for releases & Animation when a module has been installed ()
Export presets window UI ()
Improves preset tree UI and EXIF display ()
Parametric curve saving settings in layers ()
Remove OpenCollectionEvent ()
Crash on layer creation : removing save state who stack overflow ()
Export modal to window, with events, and image processing inside export ()
Undo Redo system, more user friendly + debounce on value changed ()
Clean up trigger branches list only [main, dev, release/*] ()
Complete the upload artifact path using github workflow's matrix ()
Path now includes matrix.configuration fetches from matrix instead of global env ()
Copy the brochure MD inside the "ModuleName.ARCH" folder ()
Add fondation of ModuleInstaller Helper ()
Add fondation on Marketplace View on LDA ()
Add LuxExport's luxmod.json + LuxEditor's luxmod.json files ()
Add necessary methods inside ModuleInstaller ()
Add brochure field to luxmod.json ()
Add bucket initialisation process before launching app ()
Add debug URL in allowed origins (CORS) ()
Add luxapi script to create its secrets ()
Add random username and passwd as admin user for MinIO bucket ()
add MinIO password generation script and configure environment variables in deployment ()
Remove Z-Index, and remove possibility to move masks ()
Comments norm ()
Comments norm ()
Double overlay drawing + update overlay color instantly on color changed ()
Linear and Gradial radient with the new system ()
integration LuxEditor v2 to develop branche ()
Add fondation of LuxMarketplace manager/BuildSystem segment ()
Inject GH_TOKEN as secret using Github secrets ()
Change python version from >=3.13 to >=3.11 for marketplacemgr ()
Checkout code before executing script ()
Update working directory ()
Update workflow name ()
Add GitHub Actions workflow to attach artifacts to marketplace ()
Add uploadmgr script which aims to publish a branch on target (that contains Luxoria.App & Modules folders) ()
Wait the building of Luxoria App & Modules before releasing artifacts ()
Add steps to list and zip downloaded artifacts before uploading to GitHub Release ()
Rename job identifiers ()
Add workflow_call trigger to build-upload workflows and enhance artifact release process ()
Add GitHub Actions workflow to attach artifacts to release ()
Bring docs for IJwtService ()
Create I/JwtService that handles TokenCreation ()
Generate JWT token the same way as AuthController does ()
Improve WhoAmI method (AuthController), returns User model fetched from DB, instead of reading JWT cache info ()
User retrieval from JWT token (WhoAmI method) ()
Display algorithm's row by algorithm name sorting by A-Z ()
Add fondation for FilterExplorer on LuxFilter Left-hand toolbox ()
Add logical update (filer by algoName & Ordering >=/=<) when filter has been changed ()
Add ScoreViewer in ToolBox right-hand side panel ()
Add ToolBox component which includes RatingComp on the right-hand side panel ()
Change ingress certification manager to traefik's internal certmgr ()
Add SMTP settings validation and update deployment configuration ()
Refactor URLs in CollectionController and EmailService to use dynamic configuration ()
Update API endpoint to use dynamic configuration ()
Update API URLs to use dynamic configuration from app settings ()
Enhance CollectionDetail view with scrollable gallery and mention system ()
Add CollectionChat view and integrate chat functionality with image selection and mentions ()
Add image selection modal and enhance message formatting with hashtags ()
Add Pending Registration feature with email verification ()
Add debugging step for Kustomization in deploy-to-pluto job ()
Add kubeconfig installation step in deploy-to-pluto job ()
Add kubectl installation step in deploy-to-pluto job ()
Add Kubernetes orb declaration in config.yml ()
enhance deployment process with kubectl and kustomize integration for Pluto ()
Specify target environment ()
Add timeout mechanism to kill the authentification process if callback has not been received after 120s ()
Add fondation of LuxStudio Integration Module ()
Add fondation of LuxStudio.COM Module (contains AuthService.cs) ()
Add LuxStudioConfig model and integrate configuration fetching in ConfigService ()
Add Minio service configuration to docker-compose and register MinioService in Program.cs ()
Correct SSO authorization URL to use frontend URL instead of backend URL ()
Add pull request trigger for main, develop, and release branches in workflows ()
Correct path to requirements.txt in LuxFilter model installation step ()
Remove CI branches from workflow trigger ()
Update .gitignore to include negative.txt and positive.txt ()
Add CI trigger for feature and fix branches in workflow ()
Add ONNX export functionality and requirements for CLIP model ()
Add Python 3.12 setup and install requirements for Luxoria LuxFilter Model ()
Set up Python 3.12 and install Luxoria LuxFilter Model requirements in SonarCloud analysis workflow ()
Remove LFS filter for ONNX files ()
Disable LFS storage ()
Clarify LFS disabling steps in mirror workflow ()
Improve LFS smudge disabling in mirror workflow ()
Remove duplicate Git LFS disable step in mirror workflow ()
Remove LFS smudge disabling steps from mirror workflow ()
Disable lda-build, which is a clone of build-upload-lda ()
Create a directory for each vault, and, Delete the vault's drectory when deleting the specified vault ()
Add fondation of VaultService & StorageAPI ()
Add vault management methods to IVaultService ()
Complete StorageAPI for Modules ()
Add "Start Over" button on filter's status view ()
Add ToastNotificationEvent and StartOver button on LuxImport's indexication process view ()
Bring OpenAI CLIP model as Color Visual Aesthetics analysis ()
Enhance pipeline event handling and user notifications ()
Add DesktopController for API versioning and configuration endpoint ()
Add initial migration files for database schema creation ()
Enhance DesktopController to include configuration endpoint and update appsettings for URI structure ()
Buildsystem script to build luxEditor (removing AppX in file path) ()
Contrast filter + add comments to uncommented functions ()
Exposition / contrast / tint / temperature / saturation method ()
Refactor LuxEditor for better performances ()
Add maxcpucount option to Luxoria.App build step in workflow ()
Add optional flag to disable Luxoria.SDK's PackOnBuild option ()
Add renaming steps for LuxImport, LuxFilter, LuxEditor, and LuxExport DLLs in build workflow ()
Change Reference Paths in LuxImport csproj file ()
Improve file upload validation in AuthController and update logout method in Dashboard ()
Update API_URL in config files for consistency and environment variable support ()
add real-time chat functionality with username support ()
Add user avatar upload and retrieval functionality ()
Enhance JWT token generation to include user email and secure collection retrieval with authorization ()
Implement SignalR chat functionality and add allowed email management for collections ()
Move dependabot to .github folder, from .github/workflows folder ()
Add API_URL environment variable to luxstudio container ()
Add context to build-and-push job in CircleCI configuration ()
Add debug step to check DockerHub credentials before login ()
Correct build context paths for luxapi and luxstudio in Azure Pipelines configuration ()
Add ArgoCD application configuration for LuxStudio in Pluto namespace ()
Add CircleCI configuration file for CI/CD setup ()
Add CircleCI configuration for building LuxAPI and LuxStudio Docker images ()
Add Docker and Kubernetes configurations for LuxStudio deployment ()
Add Unit tests for LuxExport ()
Clean unused code ()
Commentaries in code ()
Documentation for lux-export ()
Simplify LoadWindowCaption by using local variable 'path' ()
Add ApplicationIcon 'Luxoria_icon.ico' + Add Luxoria official logo on SplashScreen ()
Create LoadWindowCaption method to load an ico for window caption and taskbar ()
Add Filters (ReadOnlyDictionary?) in ImageData and fix some tests ()
Bring clarification and fix nullable variables object? sender => object sender ()
Changes Score alignment from Center to Right ()
Remove gray border to the ItemList on FilterView ()
Add base of filters selection with params (weight) ()
Add FilterCatalog Event to fetch the entire available filters (ReadyToUse) ()
Add StatusView foundation for LuxFilter UI (ListView, ViewModel, ...) ()
Add the Status (Logger) UI on LuxFilter 3rd part ()
Change Compute method usage in LuxFilter.Tests cases ()
Change type of return of Pipeline[Compute] method ()
Static path to assets folder on LuxFilter.TestMain ()
Update Dependabot configuration to target the develop branch for all package ecosystems ()
Add Dependabot configuration for automated dependency updates ()
Update Dependabot configuration to include commit message prefixes and scope ()
Build system of LuxImport for Unpackaged Luxoria version ()
Change view from ImportView when recentbutton is clicked ()
Check if CollectionPath already initialized, if yes, goto Indexing View ()
Unassign dialog.Content after dialog closed ()
Add a progress bar on MainImportView (X/3 steps) ()
Add base of Importation modal (ImportView) ()
Add basic layer for ImportView view ()
Add first importation step dialog (1/3) ()
Rename artifact using matrix.platform to Luxoria.App.xARCH ()
Update artifact upload name to include configuration and platform ()
Add feat/unpackaged-version branch to release workflow ()
Add upload step for Luxoria.App in release workflow ()
Code cleanup using visual studio profile 1 ()
Collection Explorer carrousel ()
Collection Explorer carrousel ()
Display flyout menu on click ()
Backend behind Graphical Test Module XAML ()
EXIFS metada pannel ()
IModuleUI Integration ()
Load component function ()
Correct formatting and style in HelloWorld.vue ()
Add base of SSO ()
Add Dashboard component with authentication guard and logout functionality ()
Add Docker configuration and initialization scripts for Luxoria database ()
Add DTOs for user login, registration, and refresh token requests; implement TokenService for secure token generation and comment in code ()
Add metrics on LuxFilter & Create Luxoria.SDK nuget ()
Add EXIF data on ImageData and Include RAW/ARW file extension inside Filter ()
Enhance EXIF orientation handling in ImageData processing ()
Refactor EXIF orientation handling in ImageData ()
Adding BrisqueInterop (C++) to BrisqueAlgo (IFilter .NET) ()
Add additional diagnostics and exporters to ImportService benchmarking ()
Add benchmarks & metrics on ImportService ()
Enhance benchmarking for ImportService with additional diagnostics and categorization ()
Update ImportServiceBenchmark to support multiple dataset paths ()
Remove Exception and Add explanations in LuxFilter.cs file ()
Add tests for all services & repositories inside LuxImport ()
Correct typo in dotnet test command for LuxFilter module in build workflow ()
Add unit tests for LuxImport module and update build workflow for coverage reports ()
Remove unused lib on LuxFilter ()
Add all test cases for LuxFilter ()
Add brisque_impl_netlib submodule for enhanced BRISQUE implementation ()
Add OpenCV & OpenCV-contrib libs for C++ ()
Add unit tests for ImageProcessing and SharpnessAlgo ()
Disable PublishReadyToRun during application build in LDA workflow ()
Remove publish step from LDA build workflow ()
Remove redundant environment variable declaration in build workflow ()
Remove runtime identifier from build command in LDA workflow ()
Add build and release workflows for Luxoria Desktop App ()
Add null handlers to events to avoid null refs ()
AddAlgorithm method returns itself ()
Removing SKBitmapWithSize, simplifying the Compute method ()
Add base of Brisque algorithm in LuxFilter ()
Add event handling and unique IDs to pipeline processing ()
Load Assemblies inside Luxoria.SDK.dll ()
Add sentry to Luxoria.SDK dll ()
Add sentry to project in LoggerService ()
Add explanations inside PipelineService file & remove unused libs ()
Add multi-thread process on compute function ()
Compute function now takes a collection of bitmaps ()
ComputeVariance function and improve code readability ()
Add base of LuxFilter module ()
Add compute sharpness of a bitmap ()
Add Filter Pipeline base ()
Add LuxFilter independant buildsystem & Add models ns in PipeSvc ()
Update LICENSE link in README to point to LICENSE.md ()
Add build step for LuxImport solution in CI workflow ()
Add docstrings to build functions for better clarity ()
Add filters in indexation process ()
All unit tests using ImageData model ()
Add Apache License 2.0 to the repository ()
Add Contributor Covenant Code of Conduct ()
Add pull request template for Luxoria contributions ()
Add test to cover LogAsync method ()
All warnings about unit tests ()
Fix sonar issues ()
Implementation of IEvent interface ()
Improve logger system ()
Add some tests to cover FileExtensionHelper class ()
Add some tests to cover Manifest model ()
Disable tests on some Event models ()
Excluding some models from coverage ()
Remove .sonar from cache exclusions in build workflow ()
Update cache paths for SonarCloud data in build workflow ()
Enable caching system on Build workflow ()
Including .sonar folder in cache ()
Execute a clean code on the overall code base ()
Include StartupTests file to test and cover Startup logic file ()
Make private assert functions static ()
Run Code-cleaner on StartupTests file ()
Add mutex (multi-thread safe) on all ImageData methods ()
Clean sonar issues on Startup file ()
Clean sonar issues on this file ()
Make UpdateSlashScreenAsync function static ()
Rename build job to scan-sonarcloud in workflow configuration ()
Update commit-checker workflow to trigger on specific pull request events ()
Change hyperlink to access to SonarCloud from main readme ()
Add SONAR_TOKEN to SonarQube analysis in GitHub Actions workflow ()
Update dotnet-coverage command in GitHub Actions workflow for improved test coverage collection ()
Add installation step for .NET coverage tool in GitHub Actions workflow ()
Update GitHub Actions workflow to use SonarCloud and improve coverage reporting ()
Clean up README formatting by adding missing div closure ()
Update README to replace SonarQube links with SonarCloud and remove development release section ()
Simplify build workflow by removing unnecessary branch triggers and updating SonarQube command ()
Remove dual SAST checker on SonarQube ()
Update build workflow to trigger on main and develop branches, and add pull request event types ()
Update SonarQube scanner options in build workflow ()
Merge develop into feat/core/main-menu ()
Removed unused files ()
Add Main Menu Bar component and module import setting ()
Add comments inside Index function ()
Add functions & methods explanations inside files ()
Add functions explanations inside 'ImportService' file ()
Cleanup the code before merge to 'develop' ()
Add a toast notification message when CollectionUpdatedEvent ()
Add base of Luxoria Indexing Process ()
Add handler to retreive updated collection on MainWindow ()
Add importation cleanup process ()
Fix documentation about technical stacks ()
Upgrade .NET version to 9.0 ()
Upgrade release workflow to use .NET 9.0 ()
Update issue templates ()
Update issue templates ()
Update issue templates ()
Exclude Startup.cs and *.xaml (design files) from code coverage analysis ()
Unit test after logger function in initialize ()
Update .gitignore file to Ignore .vscode, .DS_Store, any tmp files ()
Update commitlint.config.js to enforce subject case rules ()
Add base of processing for LuxImport ()
Add code coverage test in build workflow ()
add GitHub Actions workflow for building and packaging Luxoria.App ()
Add Luxoria.SDK project ()
Update download link in README.md ()
Add Auto release system (Semantic Release) ()
add base of .NET WinUI3 project ()
add C# .NET WinUI3 base ()
add GitHub Actions workflow for building and analyzing the project ()
Improves subject overlay and tool handling (04ca4d2)
Improves subject recognition blur application (a30c52b)
Improves subject recognition blur application (e9b0894)
Change SMTP__User to SMTP__Username (c4f40d1)
Correct secret key references for SMTP user and password in deployment configuration (3b8934f)
Improve access control checks in CollectionController and update response messages (274c366)
Improve user access checks in controllers (ab10a3f)
Remove placeholder in Get Status method (75bcb29)
Remove unnecessary confirmation URL from email template (b5de9c4)
Update hCaptcha SecretKey and SMTP configuration in appsettings (e27de2a)
LicensePath inside LuxInstall.iss file (e6f2648)
Remove default version on all installer config files (635d599)
Source path (LuxInstall.iss) on x64, x86 and arm64 (5ebbb80)
Comment out dev front urls (314b12d)
Delete default value as BaseURL in internal helper api.ts (0401edb)
Disable send button during message sending to prevent duplicate submissions (39b838d)
Entrypoint url after 2FA at registration point (4ea66fa)
Fix hydration error in login (6bd3878)
Fix photo update logic in CollectionController (9bdc830)
Ingress for Pluto env (3f64f10)
Integrate ".webp" to accepted file formats (c78e0a3)
LuxStudio's website internal port from 3000 to 3000 (fb7f6c0)
Remove unused utility function in register (6d88522)
Request POST for request verify account (acfc7a0)
Update auto-scroll behavior in chat component to improve user experience (0fc2a91)
Update button colors and hover effects for improved UI consistency (e12e2d5)
Update Google Forms links for Sentry and Feedback access requests (5b30c88)
update role select input styling for better visibility (ef3faa7)
Add endpoint to retrieve photo status by ID (e2d27ea)
Add GET API route to return SignalR URL (3e4353d)
add mention notification feature with email alerts in chat functionality (da47051)
Add migrations from LuxStudio v1 to v2 (bec5f68)
Add photo status update functionality and enhance UI for status management (bfeba8a)
Add PhotoId to ChatMessages and implement photo upload functionality in CollectionDetail (d2d4198)
Add user roles and enhance registration process (b8eeb1e)
Enhance chat functionality by including photo ID in message handling and notifications (317a4d9)
Enhance CollectionsPage with create, update, and delete functionalities (11fabae)
Implement Admin functionalities for user and collection management, including user blocking/unblocking and password reset, collections views and activity logs (e9d5282)
Implement password reset functionality (7a6d491)
implement user invitation modal in CollectionDetail component (67f7f76)
Refactor authentication and admin pages to fix warning when build (005ff8b)
refactor photo upload to take an additional parameter to override if modified (0368bc1)
Update application layout and add user reporting features, improve admin management and reports (05b9c17)
update user role assignment logic during registration for admin user (0ed207a)
Add RefreshAccessToken method in AuthService to swap for new credentials (8af96db)
Add WhoAmIAsync method and refactorisation of AccManagementView (Logic part) (0b572e3)
Adds data models and collection service (eff4687)
chat functionality and collection handling (70cb704)
collection management features (fc140f0)
Injects token into WebView2 for authentication (74e0322)
LuxStudio export (5b1ba53)
Add Mandatory folder (89dc6ac)
Add PoC List (33478bb)
Start crop box (84f16c1)
Add the cache system into VaultService & StorageAPI (6ab56d8)
View Module README + Caching backups (a9e3aa4)
Add secret vars from minio service on LuxAPI (7c234c9)
Change from debug message to Console message (a90d118)
Correct MinIO console address and environment variable values (ae9ac50)
Delete dev-only console.log & debug origin (cors) (69131e1)
Enable SSL for bucket connection (21903b3)
Rename method in BuildManager part (798648e)
Set the final path for published module directory set as "ModuleName.luxmod" (8cda6ad)
Specify namespace for luxoria/minio secret (c091a3b)
Translate error & return values and fix the asset link for retreival (26b03f0)
Translate pages in English and fix API triggering (4eb9b6d)
Update error message for invalid CreateCollectionDto (1b8f81f)
Update MinIO console address and browser redirect URL (d5f5795)
Update MinIO console address to use HTTPS (dd77511)
Update MinIO console address to use local path (2a19d82)
Update MinIO endpoint to use internal service address (2a2ddc9)
Linear gradient, 2 line instead of 3 (4a4a669)
Loading curve with default parameters (480587b)
Loading curve with default parameters (a529607)
Overlay superposition (6158e00)
Useless draw who make the current operation always visible even if there is a substract operation over it (290dc08)
Implement CollectionExplorer & AssetViewer on LuxFilter (v3) (546aec5)
Implement FlagsComponent inside Toolbox Partial View (74db3b5)
Integrate sync mechanism (event communication) between LuxFilter & LuxEditor (dd49cf1)
Update ingress name from luxstudio-staging to luxstudio-production (37e1037)
Update JWT_SECRET to use dynamic value generation (fbcbc45)
Implement photo status update functionality and enhance image selection modal (a9fd896)
Implement registration confirmation flow with email verification and new route (35e17dc)
Refactor collection access management and enhance email invitation system (569da14)
Correct kubeconfig parameter name in deploy-to-pluto job (4cb4ce6)
Correct resource file path and update create_or_update_resource syntax in deploy-to-pluto job (eb4bd57)
Enable kustomize parameter for create_or_update_resource in deploy-to-pluto job (8515e76)
Enhance image tag generation message with pipeline number (1fccb8f)
Enhance tag injection for API and Studio images in Kustomization to support multiple patterns (a1ab9b5)
Inject image tags for API and Studio in deployment configurations (6495c6e)
Refactor deploy-to-pluto job to use kustomize for resource updates (9aea55a)
Remove action-type from kubernetes/create_or_update_resource in deploy-to-pluto job (92a88e2)
Simplify image tag generation and remove pipeline number from message (520f573)
Simplify tag injection command for API and Studio images in Kustomization (a1d2e77)
Simplify tag injection for API and Studio images in Kustomization (3566c85)
Update CircleCI commands to use --environment flag (c70777f)
Update CircleCI commands to use --environment-name and --namespace flags for Pluto (9b8ca66)
Update deploy-to-pluto job to use Docker executor instead of Kubernetes executor (2691eb5)
Update deploy-to-pluto job to use Kubernetes executor and specify environment (548c10a)
Update image tag injection for API and Studio in Kustomization (21a3d16)
Update image tag injection for API and Studio in Kustomization to use improved regex (bf1195d)
Update Ingress name from luxstudio-staging to luxstudio-production (97fe24c)
Update parameters for create_or_update_resource in deploy-to-pluto job (91d0408)
Update release status commands in deploy-to-pluto job (346e414)
Update resource file path for create_or_update_resource in deploy-to-pluto job (8974dff)
Update tag injection for API and Studio images to use improved regex pattern (2913da4)
Add StopLoginFlow method which allows to terminate the listener process waiting for authentification over web browser (6e15024)
Enhance SSO login flow with additional logging for better traceability (a6217f0)
Implement ConfigService for managing configuration settings and URL validation (f777d7d)
Implement SSOService for handling Single Sign-On logic and authorization flow (9d3369b)
Update AuthService with logging and restructure project file (898203d)
Update docker-compose and AuthService for external URLs and configuration integration (d1ce664)
Update ONNX export script to accept output directory as an argument (c699539)
Remove push trigger from workflow files (662c4aa)
refactoring luxeditor for better performances (be16379)
refactoring luxeditor for better performances (09593cc)
Removing clarity filter (2e0fb2a)
Rework Editor Module, removing xaml code for modularity (1452ded)
Texture function (d0d6b7b)
Using separators between sliders and reorganizing the sliders (8964b47)
Using separators between sliders and reorganizing the sliders (e5c446c)
Cleanup unused dependencies in LuxImport (d9843df)
Correct artifact paths for LuxImport, LuxFilter, LuxEditor, and LuxExport in build workflow (ba1225e)
Enhance platform targeting for Luxoria.App build step to include win-arm64 (c155fae)
Expand platform matrix to include win-x86 and win-arm64 for build jobs (a4a8215)
Refactor DLL renaming steps for LuxImport, LuxFilter, LuxEditor, and LuxExport to use Join-Path for improved path handling (065e7af)
Replacing DLLRef by ProjectRef for both Luxoria.GModules & Luxoria.Modules (d97f099)
Update artifact paths and rename steps for LuxImport, LuxFilter, LuxEditor, and LuxExport in build workflow (1ecf85a)
Update artifact paths for LuxImport, LuxFilter, LuxEditor, and LuxExport in build workflow (991449b)
Update artifact paths for LuxImport, LuxFilter, LuxEditor, and LuxExport in build workflow (6c70b31)
Update build steps to use 'dotnet build' for LuxImport, LuxFilter, LuxEditor, and LuxExport, and adjust artifact paths (23c5c8d)
Update build steps to use 'dotnet publish' for LuxImport, LuxFilter, LuxEditor, and LuxExport (c055bc0)
Update build steps to use 'dotnet publish' for LuxImport, LuxFilter, LuxEditor, and LuxExport, and adjust artifact paths (fda3076)
Update build workflow to enhance module upload steps and improve comments for clarity (6af42f1)
Improve avatar handling and user feedback in registration and collection management (5bdf4c3)
update Vite version and add CollectionDetail view (70b3732)
Move context declaration for build-and-push job to workflows section (b086199)
Rename job from build-images to build-and-push and update logging steps (af1d20b)
Rename job from build-local to build-images and update image tag logging (621bb85)
Restore imageTag variable format for tagging in Azure Pipelines (214b2d1)
Update display name for BuildAndPush stage in Azure Pipelines configuration (0e9447c)
Update display name for BuildAndPush stage in Azure Pipelines configuration (0af18c8)
Update Docker login command for consistency in username flag usage (e3537e4)
Update Dockerfile paths for luxapi and luxstudio in Azure Pipelines configuration (2d896d4)
Update FrontEnd__URI and API_URL environment variables for luxapi and luxstudio deployments (673eb81)
Update imageTag variable format for consistency in Azure Pipelines (e8aea4c)
Update imageTag variable format for consistency in Azure Pipelines (6052948)
Update imageTag variable to use Build.BuildId for tagging in Azure Pipelines (c70c2ba)
Update imageTag variable to use Build.BuildNumber for consistency in Azure Pipelines (646d314)
Update imageTag variable to use Build.SourceVersion for tagging in Azure Pipelines (1f8aa5d)
Update imageTag variable to use conditional logic for tagging in Azure Pipelines (31393a4)
Update ingress configuration to use luxstudio-service instead of pluto-service (bfa3c60)
Update ingress configurations for LuxStudio in Pluto and Saturn namespaces to include TLS settings and cert-manager annotations (bfdd9b0)
Update kustomization.yaml to use patches with target for ingress configuration (93a91d5)
Update secretName for TLS configuration in luxstudio-ingress (bbe93a1)
Update secretName for TLS configuration in luxstudio-ingress (fca2963)
Add Docker support with Dockerfile, entrypoint script, and .dockerignore; include config.js for runtime API URL replacement (9a361de)
Add luxportal service to Docker Compose; update routing and error handling in Login component (31216ba)
Add Minio configuration and implement collection-related models with relationships (524f688)
Add starter Azure Pipelines configuration (92e8416)
Enhance SystemController to include database connectivity checks and update Docker Compose for improved service configuration (9785604)
Implement dynamic image tagging in CircleCI configuration (f9020de)
Remove old ingress and configmap configurations; add new deployment and service for LuxStudio in Pluto and Saturn namespaces (67c198f)
Update Azure Pipelines configuration for Docker builds; remove unused adminer service from Docker Compose (589580c)
Update Dockerfile for specific Node and Nginx versions; add nginx.conf for server configuration; refactor auth services to use dynamic API URLs from appConfig (5dfc019)
Export File Naming backend (f1ace86)
Export location back-end (1a9fc8d)
Export location back-end (7fce05d)
Export Pop Up with progress bar and previsualization (af849b8)
File Path for assets + color profile + removing broken file format (845c5ba)
File Picker in content dialog + content dialog size (a658ef3)
Initialisation of the modal using LMGUI (32b1eb7)
Lux Export Interface (769e797)
Lux Export Interface (e8f7c28)
LuxExport refactor from window to modal (e658762)
Update counter value on multiple photo export (672312f)
Using window instead of modal because of WinUi restrictions (9a8f279)
Remove total weight (1.0 => 100) on the PipelineService (13c4db9)
Replace Dictionary by ImmutableDictionary (Catalog) in FilterService (0ac9ee7)
Upgrade Luxoria.Algorithm.BrisqueScore from 3.0.2.4100 to 3.0.3.4100 (5633377)
Create Filtering Status View (LuxFilter.Views.StatusView) (535adb0)
Add foundation for Importation views part 1/3, 2/3, 3/3 (7b665bc)
Add RICollectionRepository system to handle the Recents Imported Collection list (9c176fc)
Add the Indexication Log viewer on Indexication view (3/3) (e47182c)
Create new buildsystem for LuxImport and Creation of LuxImport 1.0.2 (4df8a00)
Create RequestWindowHandleEvent event to retreive Main Window Ptr (f5a34f4)
Include Luxoria.SDK nuget instead of Luxoria.SDK.dll (a6cee2f)
Update components on Properties view (901fc21)
SkiaSharp library (5ebd5cf)
Sliders in Editor pannel (3853302)
Module in panel integration (0a503e9)
Upgrade Modules SDK to include Windows SDK (3d78906)
Add EF connection to LuxAPI (8a9e395)
Add GitHub Actions workflow for LuxAPI build process (981ee30)
Add initial implementation of LuxAPI (b552d7c)
Add TailwindCSS + DaisyUI on LuxStudio Portal (2b54396)
Add UserId to AuthorizationCode model and implement SSO authorization view (bf5d767)
Enhance JWT token generation with user ID and add WhoAmI endpoint for user info retrieval (1579f96)
Implement authentication with login and registration views, add router, and configure CORS (3d539c9)
Implement JWT authentication and configure Swagger for API security (799c33b)
Increase token field size to TEXT for AccessToken and RefreshToken in Token model (9a1e2f3)
Initialize Vue 3 + TypeScript + Vite project with basic structure and configuration (909aace)
Refactor Token model to use UserId and add RefreshToken model with related functionality (96e9634)
Update models to use required properties for better validation; adjust nullable types where necessary (83f82bf)
Update package dependencies and add Vue type definitions; enhance router token handling (73350d5)
Encapsulate BrisqueAlgorithm inside BrisqueAlgorithm.hpp (ad8272c)
Update build workflow to include LuxFilter and merge coverage reports (efaa01d)
Update CMake configuration and enhance BRISQUE implementation with error handling (3fa70a2)
Set working directory for build and publish steps in LDA workflow (7c1d3c5)
Specify runtime identifier for LDA project build in workflow (2dd9a1a)
IPipeline.Compute return fscore as double instead of void (b21f8d4)
Make ApplyLaplacianKernel function as static (8e3b2ec)
Move BitmapWithSize model to its unique file & remove unused model (3df6b1c)
Use Multi-Thread in pipeline computation (e384533)
Add Resolution Algorithm to Algorithms code-base (9d0cd9d)
Add Rust logic functions for LuxFilter (cdf3b36)
Increment LuxImport's version from 1.0.0 to 1.0.1 (1c0cd97)
Replace buildsystem by one that build the entire solution (2108176)
Replace ReadOnlyMemory with SKBitmap (22b893c)
Update SonarCloud analysis job name in CI workflow for Luxoria (adfe133)
Update SonarCloud analysis step in CI workflow for Luxoria.App (518c53b)
Create Luxoria.App graphical architecture (a21021a)
LuxConfigRepository read Guid from json file (b411639)
Move 'LuxVersion' inside Luxoria.Modules.Models namespace (df154d4)
Optimization of Index function in ImportService (dc51033)
Rename LuxAsset.Config to LuxAsset.MetaData (ba148c9)
Add Load Image bitmap using SixLabors.ImageSharp lib (92a655f)
Adding LuxCFG creation processus in indexication process (b70b685)
Change mono-thread to multi-threads indexation process (5983b22)
Close modal when importation is completed or has failed (8dd21e7)
Refactor module loading logic in App.xaml.cs to load from directories with logging for missing modules. (5b51c0c)
Upgrade 'LuxImport' solution to .NET 9.0 (53afe91)
Update README.md and package-lock.json (549f988)
add modular-arch (Luxoria.App) into main Luxoria repository (c39fa25)
Add UnitTest base (c5688eb)
Create a second module called TestModule2 (7603f00)
fix GitHub Actions workflow for building and packaging Luxoria.App (819ce3b)
fix GitHub Actions workflow for detecting Q&A / SAST (42f5068)
Fix ModuleServiceTests to include logger service in initialization (fb2a32e)
Install dotnet-coverage globally and configure OpenCover reports (b2a116c)
Refactor project structure and ignore files (eefc7aa)
Update release workflow to only build for x64 platform (143f418)
Update test command in build workflow (a4b3959)
Update test command in build workflow (f2d9170)
add gitignore and husky configuration files (f9e0f71)
Add links to download, documentation, and contribute in README.md (b2c587e)
Add Luxoria Documentation (3bf3421)
add publish profiles inside repository (1426a90)
fix ci/cd Build and analyze step (9579291)
fix ci/cd Build and analyze step (198b0c5)
fix ci/cd build part by specifying target build name (05d9c01)
fix download link in README.md (f3cb3af)
fix exclude some files from SonarQube Analyze (d86d1d0)
fix Luxoria README.md and add documentation (a6f5cfd)
fix publisher profile name to "Luxoria Project" (1df3600)
update SonarQube project badges URLs (2d5a6f0)