Padle

padle

Simplifying Transformer Models for Faster Training and Better Performance

MVP Game Development With Flutter and Flame

ফ্লটার এবং ফ্লেম সহ MVP গেম ডেভেলপমেন্ট

MVP-Spieleentwicklung mit Flutter und Flame

Desarrollo de juegos MVP con Flutter y Flame

Développement de jeux MVP avec Flutter et Flame

फ़्लटर और फ्लेम के साथ एमवीपी गेम डेवलपमेंट

Flutter と Flame を使用した MVP ゲーム開発

Flutter 및 Flame을 사용한 MVP 게임 개발

Desenvolvimento de jogos MVP com Flutter and Flame

Разработка игр MVP с Flutter и Flame

Flutter ve Flame ile MVP Oyun Geliştirme

Phát triển trò chơi MVP với Flutter và Flame

使用 Flutter 和 Flame 进行 MVP 游戏开发

Navigation with Large Language Models: Discussion and References

Gemini - A Family of Highly Capable Multimodal Models: Discussion and Conclusion, References

RISC-V is an open-source instruction set architecture (ISA) that has gained popularity due to its simplicity and flexibility. In this article, we’ll explore the fundamentals of RISC-V assembly language by building an assembler in C#. Our goal is to read RISC-V assembly code, identify the instruction type, and convert it into machine code. We’ll use Visual Studio as our development environment for this project. Setting Up the Project Let’s begin by creating a new project in Visual Studio. We’ll build our RISC-V assembler step by step. We mention that we will be building the assembler incrementally, and the first task is to set up a loop to read a file containing RISC-V assembly code and iterate over each line. This loop will serve as the foundation for processing the assembly code. string[] lines = File.ReadAllLines(filePath);

foreach (string line in lines)
{
  // Process the 'line' here, e.g., identify instruction type, parse, and convert to machine code
} Identifying Instruction Types RISC-V instructions are categorized into different types: R, U, I, B, S, and J. To determine the type of instruction, we’ll use a lookup table for opcodes, func2, and func7. You can find the lookup table in this . file Here’s an example of how to identify the instruction type: switch (opCode)
{
    case (OpCode)0b0110011:
        return InstructionType.R;
    case (OpCode)0b0010111:
        return InstructionType.U;
    case (OpCode)0b0110111:
        return InstructionType.U;
    case (OpCode)0b0010011:
        return InstructionType.I;
    case (OpCode)0b1100011:
        return InstructionType.B;
    case (OpCode)0b0000011:
        return InstructionType.I;
    case (OpCode)0b0100011:
        return InstructionType.S;
    case (OpCode)0b1101111:
        return InstructionType.J;
    default:
        return InstructionType.Unknown;
} You can find the implementation of this function in the file. RiscVAssembler.cs Parsing Instructions Now that we can identify the instruction type, let’s parse each instruction based on its type. We’ll start with the R-type instructions, which have the syntax: . op rd, rs1, rs2 For example, the instruction can be parsed as follows: add x10, x1, x2 Regex rTypeRegex = new Regex(@"^(\w+)\s+(\w+),\s+(\w+),\s+(\w+)$");
Match rTypeMatch = rTypeRegex.Match(instruction);
if (rTypeMatch.Success)
{
    return new RiscVInstruction
    {
        Instruction = instruction,
        Opcode = rTypeMatch.Groups[1].Value,
        Rd = rTypeMatch.Groups[2].Value,
        Rs1 = rTypeMatch.Groups[3].Value,
        Rs2 = rTypeMatch.Groups[4].Value,
        Immediate = null,
        InstructionType = InstructionType.R
    };
} You can find the complete implementation of the R-type instruction parser in the file. R_Parser.cs Converting to Machine Code Once we’ve parsed an instruction, we can convert it into machine code. Each instruction type has its own format. For R-type instructions, the format is as follows: R type: .insn r opcode6, func3, func7, rd, rs1, rs2
+-------+-----+-----+-------+----+---------+
| func7 | rs2 | rs1 | func3 | rd | opcode6 |
+-------+-----+-----+-------+----+---------+
31      25    20    15      12   7        0 For example, the instruction is translated into , where: add x10, x1, x2 00000000001000001000010100110011 Opcode 6: 0110011 Rd = 01010 Func 3 = 000 Rs1 = 00001 Rs2 = 00010 Func7 = 0000000 Here’s an example of how to convert the parsed instruction into machine code: string opcode = ((int)instruction.OpcodeBin).ToBinary(7);
string rdBinary = Convert.ToString(int.Parse(instruction.Rd.Substring(1)), 2).PadLeft(5, '0');
string func3 = ((int)instruction.Funct3).ToBinary(3);
string rs1Binary = Convert.ToString(int.Parse(instruction.Rs1.Substring(1)), 2).PadLeft(5, '0');
string rs2Binary = Convert.ToString(int.Parse(instruction.Rs2.Substring(1)), 2).PadLeft(5, '0');
string func7 = ((int)instruction.Funct7).ToBinary(7);

return new MachineCode($"{func7}{rs2Binary}{rs1Binary}{func3}{rdBinary}{opcode}", instruction.Instruction); You can find the complete implementation of machine code generation in the file. R_MachineCode.cs Conclusion In this article, we’ve embarked on a journey to learn RISC-V assembly language by building an assembler in C#. We’ve covered the basics of reading RISC-V assembly code, identifying instruction types, parsing instructions, and converting them into machine code. This project serves as a valuable learning experience for understanding the inner workings of RISC-V assembly language and its translation into machine code. To delve deeper into the RISC-V architecture, refer to the . RISC-V Specification Here’s the GitHub repository link for the project where you can find the code for building a RISC-V assembler in C#: . SharpRISCV GitHub Repository If you find the project helpful and informative, don’t forget to give it a star on GitHub to show your support. In the of our RISC-V assembly language learning series, we will explore , which are essential concepts for understanding and writing more complex assembly programs. Stay tuned for the next installment! next part addressing modes, labels, and offsets Also published . here

Understanding RISC-V Assembly Language by Building an Assembler in C#

My blogs chronicle my experience as a technologist making my way into Silicon Valley. I am a queer person of color, gender non-conforming, immigrant, and ex-foster youth. I come from a non-traditional coding background. I studied a few CS courses in college and ended up majoring in the humanities before becoming a teacher. Teaching web development to under served teens turned me on to coding. After finishing at a coding school, I began working at start ups in San Francisco. Half of my blogs are about technical subjects and the other half are about equality and tech access (my journey). During the days of Windows 95 right before the internet arrived, a lot of the apps we used lived in our desktop PCs. Applications of varied sizes ran our computers. These programs allowed us to play games, manage tasks, interact with audio/video files, and save files onto disks. Browser (UI) testing an application meant writing a program that would take screenshots while a user interacted with its features. Everything QA engineers needed to test had to go through the front end. You can imagine this was expensive (CPU costs) and time consuming. These days, most of the applications we use live on the web or as apps on our smartphones. User interaction (UI) and the front end have become extremely important. Sleek UI design can set an application apart from its competitors. As the front end of applications become more complex so has UI testing. Though in some sense, UI testing still tends to be brittle, advancement in UI testing tools have allowed engineers more capabilities to test the UI than ever before. This blog will walk you through how to write a log in test using page and . . At a high level, page objects are just objects OR classes that represent a page of an application and its functionality. It does not have to represent the ENTIRE page. It could be a section of the page, for example the navbar. object models NightwatchJS Here is an in depth overview of page object models Page Object Models allows us to be able to separate the tests for a page from its selectors, layout and functionality. NightwatchJS uses an object syntax for its page objects. Let’s write a basic test in NightwatchJS and then refactor that using the Page Object Model. Create a new directory where we will store our test folder along with our page objects. mkdir nightwatch-pageObjectcd nightwatch-pageObjectmkdir ui_tests Initialize your node package manager. cd nightwatch-pageObjectnpm init Once you see your file, install Nightwatch globally so you can have access to its commands. You will also need to install it as a dependency to be able to run our tests. package.json npm install -g nightwatchnpm install nightwatch --save-dev To automate our tests and be able to control the browser, we will need to be able to start the server. Make sure you have java, to check type Selenium java -version If you don’t, check out these docs Nightwatch has the ability to run the server automatically through its test runner. Let’s create a nightwatch.conf.js file at the top level directory. touch nightwatch.conf.js We’ll cut and paste a basic config file for now, which can be found here const seleniumServer = require("selenium-server");const chromedriver = require("chromedriver");const SCREENSHOT_PATH = "./screenshots/"; module.exports = {"src_folders": ["test/ui_tests"],"output_folder": "./reports","selenium": {"start_process": true,"server_path": seleniumServer.path,"host": "127.0.0.1","port": 4444,"cli_args": {"webdriver.chrome.driver" : chromedriver.path}},"test_settings": {"default": {"screenshots": {"enabled": true,"path": SCREENSHOT_PATH},"globals": {"waitForConditionTimeout": 5000},"desiredCapabilities": {"browserName": "chrome",}}}}; function padLeft (count) { // theregister.co.uk/2016/03/23/npm_left_pad_chaos/return count < 10 ? '0' + count : count.toString();} var FILECOUNT = 0; // "global" screenshot file count/*** The default is to save screenshots to the root of your project even though* there is a screenshots path in the config object above! ... so we need a* function that returns the correct path for storing our screenshots.* While we're at it, we are adding some meta-data to the filename, specifically* the Platform/Browser where the test was run and the test (file) name.*/function imgpath (browser) {var a = browser.options.desiredCapabilities;var meta = [a.platform];meta.push(a.browserName ? a.browserName : 'any');meta.push(a.version ? a.version : 'any');meta.push(a.name); // this is the test filename so always exists.var metadata = meta.join('~').toLowerCase().replace(/ /g, '');return SCREENSHOT_PATH + metadata + '_' + padLeft(FILECOUNT++) + '_';} module.exports.imgpath = imgpath;module.exports.SCREENSHOT_PATH = SCREENSHOT_PATH; Whew, that’s a lot of code. Don’t fret, it’s dense but readable. First, let’s install selenium-server and chromedriver npm install selenium-server chromedriver --save-dev Here’s a quick run down of the code you pasted into your file: nightwatch.conf.js Requires selenium-server and chromedriver const seleniumServer = require("selenium-server");const chromedriver = require("chromedriver"); 3. Tells Nightwatch where the test code is located "src_folders": ["test/ui_tests"], 4. Makes sure the test runner starts the selenium server "start_process": true, 5. Selects Chrome as your desired browser "desiredCapabilities": {"browserName": "chrome",} Now, let’s run the config file to download selenium-server. node nightwatch.conf.js We’re ready to write our tests. Let’s write a simple test that goes to Google’s website and checks if the page title is correct. cd ui_teststouch sauceLabs.js First, require our new Nightwatch config file: require('../../nightwatch.conf.js'); Next, let’s write our test in the same file. Nightwatch uses its own syntax which is less verbose than some test frameworks like mocha. module.exports = {"Validate Sauce Labs' Page Title": function(browser) {browser.url('https://saucelabs.com').waitForElementVisible('body').assert.title('I am a page title - Sauce Labs').saveScreenshot('saucelabs.png').end();}}; Let’s run our test that validates Sauce Lab’s page title. node_modules/.bin/nightwatch --config nightwatch.conf.js Let’s store this command into a in our file so we can simply call . script package.json npm test "scripts": {"test": "node_modules/.bin/nightwatch --config nightwatch.conf.js"} Let’s run our test again using our newly made script. npm test Woo hoo! The automated browser worked and our 2 tests passed. In the next part, we’ll rewrite this simple test using the page object model.

Writing UI Tests Using Page Object Models With NightwatchJS Part I

A key technique in image editing applications is determining the dominant colors. The identification of these dominant colors is essential for creating an image's palette, which, in turn, accurately reflects the effect of selected tools and the results of editing. This article will delve into how to determine an image's palette within a restricted color space, identify an image's dominant colors, and differentiate between a palette and dominant colors. Palette The image palette is typically a reference to all the colors present in the original image. In essence, it captures the entire range of color shades, based on the numerical scale of color stimulus signal values. If we agree on modeling a signal with a certain level of accuracy, then the range of these signal values will represent our available color palette. Each unique representation of an image and the mapping of an image's colors onto this space will be a subset of it. In digital signal processing (an image is also a signal), we often understand a variety of quantities through its discrete representation. Thus, our image palette can be viewed as a subset of all the colors in the image represented by a discrete map. Each color can be indexed and assigned a specific value in one of the color spaces. For our purposes, we'll use the RGB color model. A significant challenge in presenting the image palette in this way is the vastness of human visibility. It's unlikely we can manually analyze the entire image palette, and it often doesn't make sense to store an image represented by all the original colors. Instead, we reduce their number to a reasonable limit. This process, known as color quantization, involves lowering the number of colors from the full subset that can be represented in an image to a smaller one. For instance, 14-bit raw color data might be represented in 8-bit JPEG or 16-bit TIFF converted to 8-bit PNG. A straightforward solution to determine an image's primary colors is to envision the process of color quantization to a very limited set, such as 8 or even 3 colors. This gives us insight into the primary colors within the image, making them more noticeable and memorable. Ideally, the colors in the final image should be harmonious, following the principles outlined by or . Johannes Itten Matyushin By identifying the dominant colors of an image, we can create a tool that allows us to visualize the image's "harmony." This can also apply to the harmony of the image after filtering, or "synthetic harmonization." Below, we will make an attempt to develop such a tool. Median Cut A widely used and high-quality algorithm for compressing an image's palette is the Median Cut algorithm. It's incorporated into most major lossy image compression algorithms, such as JPEG, albeit with some modifications. The fundamental principle of the Median Cut algorithm is to sequentially divide the image's cubic histogram into medians. Each resulting subcube contains approximately an equal number of bins, or pixels of the same color. Once the division process reaches a predetermined number of subcubes, we calculate the average color of each cube and map it to the corresponding colors of the original image. This process effectively reduces the number of colors in the original image, allowing us to compress the image into a smaller file size. It might seem at first glance that the initial part of this algorithm could solve our problem of identifying the primary or dominant colors of an image. However, a potential issue arises when the number of colors into which we divide the image is too few, and we're only analyzing a small number of colors. We might end up identifying colors that don't actually exist in the image because the colors are excessively averaged. We could choose the color with the maximum bin from each cube and label it as dominant, but then it wouldn't constitute a palette anymore. So, we'll reserve this approach for determining of the image's palette, which can also be used as a tool for visually analyzing the image in terms of its "harmonious utility." To identify the dominant colors, we'll employ statistical analysis: searching for local maxima in the same cubic histogram. a compressed version Local Maxima To identify the local maxima, we will implement a specific code. The author, who is also a skilled artist, provides an excellent description of the algorithm. Essentially, we first gather the image statistics into the same three-dimensional RGB histogram used in the Median Cut algorithm. Each cell of the cubic histogram will contain color bins, and the sum of all values of each color included in the cell. Given the limited histogram dimension to a resolution of 32x32x32 (originally 30x30x30), accumulating the sum simplifies the calculation of the average cell color. We then search for the local maximum by thoroughly exploring the entire space and comparing it with neighboring cells. Following this, we iteratively reduce the number of local maxima to the required amount, discarding similar colors with less weight. For all remaining local maxima, we calculate the average colors of all values included in the list. Since the color density in local maxima is higher, and the difference between pixel values is smaller than in cubes from the Median Cut, the colors will be more akin to those present in the main image and will more accurately represent its dominant colors. This reveals the primary difference between the two models: acquiring a versus searching for local maxima or . By mapping the primary "compressed palette" image, we will create a new one , albeit in a vastly truncated form. "compressed palette" dominant colors that maintains the same color balance as the main image On the other hand, dominant colors . They cannot be transformed into anything new with a suitable color balance. only describe the composition of the colors primarily present in the image Implementation Using this task as an example, we will demonstrate how straightforward it is to develop a ready-to-use application for image analysis and manipulation using the . We will begin with functionalities that are absent in other engines. IMProcessing Framework For instance, the framework has the capacity to read Adobe files with pre-existing CLUTs and can extract a three-dimensional cubic histogram from an image in real-time. .cube Capitalizing on this, we aim to create an application that can: Upload files in JFIF (jpeg) format. “Normalize” the original image. Control the intensity of the “normalizer.” Incorporate an arbitrary LUT from an Adobe .cube file into the processing. Manage the intensity of CLUT's impact. Display a linear histogram of the image. Exhibit the “compressed palette” and dominant colors of the image as well as their numerical representation in the form of a triplet (r,g,b) The end product of our construction will resemble this interactive toy: Here, it's clear how the image's simple “normalization” positively influences the diversity of the final palette, re-distributing dominant colors into a more varied and harmonious set. "Normalizer" We will assemble a filter from two pre-existing ones: - allows the stretching of the image histogram to specified boundaries IMPContrastFilter - performs automatic white balance correction based on the search for the average color and the correction of spurious tones in the image. This is essentially a slight modification of an idea borrowed from IMPAutoWBFilter . Andrey Zhuravlev’s blog import IMProcessing
 
/// Image filter
public class IMPTestFilter:IMPFilter {
 
    /// We will use a contrast control filter through histogram stretching
    var contrastFilter:IMPContrastFilter!
 
    /// Auto white balance filter
    var awbFilter:IMPAutoWBFilter!
 
    /// Image Linear Histogram Analyzer
    var sourceAnalyzer:IMPHistogramAnalyzer!
 
    /// Solver of the histogram analyzer for calculating the lightness boundaries of the image
    let rangeSolver = IMPHistogramRangeSolver()
 
    public required init(context: IMPContext) {
        super.init(context: context)
 
        //  Initialize filters in context
        contrastFilter = IMPContrastFilter(context: context)
        awbFilter = IMPAutoWBFilter(context: context)
 
        // Add filters to the stack
        addFilter(contrastFilter)
        addFilter(awbFilter)
 
        // Initialize the histogram analyzer
        sourceAnalyzer = IMPHistogramAnalyzer(context: self.context)
 
        // Add a light boundary search solver to the analyzer
        sourceAnalyzer.addSolver(rangeSolver)
 
        // Add an observing handler to the filter for
        // to pass the current image frame to the analyzer
        addSourceObserver { (source) - Void in
            self.sourceAnalyzer.source = source
        }
 
        // Add an observing handler for updating analysis calculations to the analyzer
        sourceAnalyzer.addUpdateObserver({ (histogram) - Void in
        // set the lightness boundaries in the contrast filter each time the image changes
            self.contrastFilter.adjustment.minimum = self.rangeSolver.minimum
            self.contrastFilter.adjustment.maximum = self.rangeSolver.maximum
        })
 
    }
} Palette Solver The IMProcessing Framework stands out from many similar platforms due to its unique organization of calculations. It uses a dedicated group of filters that essentially are not processing filters. The objects of these classes do not modify the image in the homogeneous and spatial domains. Instead, they perform certain calculations and representations of metrics for analysis in special expanders to solve specific problems. For instance, an object of the IMPHistogramAnalyzer class can simultaneously add multiple solvers that calculate the average color of the image, the light range, zonal division, etc. We use the solver to extend the analysis of IMPHistogramCubeAnalyzer to calculate the palette and the list of dominant colors. The calculation results are then displayed in an updated NSTableView. import IMProcessing
 
///  Types of distribution of image color accents
///
///  - palette:   palette for quantizing image colors.
///               calculated using the median-cut transformation scheme:
///               http://www.leptonica.com/papers/mediancut.pdf
///  - dominants: calculation of dominant colors of an image by searching for local maxima
///               color distribution density functions:
///               https://github.com/pixelogik/ColorCube
///
public enum IMPPaletteType{
    case palette
    case dominants
}
 
/// Solver of the cubic color histogram analyzer IMPHistogramCubeAnalyzer
public class IMPPaletteSolver: IMPHistogramCubeSolver {
 
    /// Maximum number of palette colors for analysis
    public var maxColors = Int(8)
 
    /// List of found colors
    public var colors = [IMPColor]()
 
    /// Palette type
    public var type = IMPPaletteType.dominants
 
	  /// Solver handler handler
    /// - parameter analyzer: link to the analyzer
    /// - parameter histogram: cubic histogram of the image
    /// - parameter imageSize: image size
    public func analizerDidUpdate(analizer: IMPHistogramCubeAnalyzer, histogram: IMPHistogramCube, imageSize: CGSize) {
 
        var p = [float3]()
        if type == .palette{
            p = histogram.cube.palette(count: maxColors)
        }
        else if type == .dominants {
            p = histogram.cube.dominantColors(count: maxColors)
        }
 
        colors.removeAll()
 
        for c in p {
            colors.append(IMPColor(color: float4(rgb: c, a: 1)))
        }
    }
} We Assemble All the Components in the View Controller The controller will need the main application filter, which we'll call , a CLUT filter named IMPLutFilter, the ready-to-use IMPHistogramView for displaying a "regular" histogram, the IMPHistogramCubeAnalyzer which is a cubic histogram analyzer to which we will attach our solver, the IMPPaletteSolver. IMPTestFilter Lastly, we'll use IMPImageView as the main window for displaying the image, and the common IMPContext is the key class used by all constructors of the framework. class ViewController: NSViewController {
 
    //
    // Processing context
    //
    let context = IMPContext()
    //
    // Window for presenting the loaded image
    //
    var imageView:IMPImageView!
 
    var pannelScrollView = NSScrollView()
 
    //
    // Window for displaying the image histogram
    //
    var histogramView:IMPHistogramView!
 
    //
    // NSTableView - views of a list of colors from the palette
    //
    var paletteView:IMPPaletteListView!
 
    //
    // Main filter
    //
    var filter:IMPTestFilter!
 
    //
    // CLUT filter from Adobe Cube files
    //
    var lutFilter:IMPLutFilter?
 
    //
    // Analyzer of a cubic histogram of an image in RGB space
    //
    var histograCube:IMPHistogramCubeAnalyzer!
 
    //
    // Our solver for finding colors
    //
    var paletteSolver = IMPPaletteSolver()
 
    var paletteTypeChooser:NSSegmentedControl!
 
    override func viewDidLoad() {
 
        super.viewDidLoad()
 
        configurePannel()
 
        //
        // Initialize the objects we need
        //
 
        filter = IMPTestFilter(context: context)
 
        histograCube = IMPHistogramCubeAnalyzer(context: context)
        histograCube.addSolver(paletteSolver)
 
        imageView = IMPImageView(context: context, frame: view.bounds)
        imageView.filter = filter
        imageView.backgroundColor = IMPColor(color: IMPPrefs.colors.background)
 
        //
        // Add another handler to monitor the original image
        // (another one was added in the main filter IMPTestFilter)
        //
        filter.addSourceObserver { (source) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            //
            // to minimize calculations, the analyzer will compress the image to 1000px on the wide side
            //
            if let size = source.texture?.size {
                let scale = 1000/max(size.width,size.height)
                self.histograCube.downScaleFactor = scale.float
            }
        }
 
        // Add an observer to the filter to process the filtering results
        //
        filter.addDestinationObserver { (destination) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
 
            // pass the image to the histogram indicator
            self.histogramView.source = destination
 
            // pass the result to the cubic histogram analyzer
            self.histograCube.source = destination
        }
 
        //
        // The results of updating the analyzer calculation are displayed in the color list window
        //
        histograCube.addUpdateObserver { (histogram) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                self.paletteView.colorList = self.paletteSolver.colors
            })
        }
 
        view.addSubview(imageView)
 
....
 
        IMPDocument.sharedInstance.addDocumentObserver { (file, type) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            if type == .Image {
                do{
                    //
                    // Load the file and associate it with the filter source
                    //
                    self.imageView.source = try IMPImageProvider(context: self.imageView.context, file: file)
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        self.zoomFit()
                    })
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
            else if type == .LUT {
                do {
 
                    //
                    // Initialize the CLUT descriptor
                    //
                    var description = IMPImageProvider.LutDescription()
                    //
                    // Load CLUT
                    //
                    let lutProvider = try IMPImageProvider(context: self.context, cubeFile: file, description: &amp;amp;amp;amp;amp;amp;amp;amp;amp;description)
 
                    if let lut = self.lutFilter{
                        //
                        // If a CLUT filter has been added, update its LUT table from the file with the received descriptor
                        //
                        lut.update(lutProvider, description:description)
                    }
                    else{
                        //
                        // Create a new LUT filter
                        //
                        self.lutFilter = IMPLutFilter(context: self.context, lut: lutProvider, description: description)
                    }
 
                    //
                    // Add a LUT filter, if this filter has already been added nothing happens
                    //
                    self.filter.addFilter(self.lutFilter!)
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
        }
 
   .... As you can see, photo processing is becoming simpler and more accessible to average users, making it possible for virtually anyone to master this process. The entire project can be downloaded, assembled, and tested from the project : . For proper assembly, the mega-library for working with JPEG files (JFIF), , must be locally installed. ImageMetalling repository ImageMetalling-08 libjpeg-turbo Currently, this is the best implementation of support for this format.

How to Create an Application to Determine the Palette and Dominant Colors of an Image

একটি চিত্রের প্যালেট এবং প্রভাবশালী রঙ নির্ধারণের জন্য কীভাবে একটি অ্যাপ্লিকেশন তৈরি করবেন

So erstellen Sie eine Anwendung zum Bestimmen der Palette und der vorherrschenden Farben eines Bildes

Cómo crear una aplicación para determinar la paleta y los colores dominantes de una imagen

Comment créer une application pour déterminer la palette et les couleurs dominantes d'une image

किसी छवि के पैलेट और प्रमुख रंगों को निर्धारित करने के लिए एप्लिकेशन कैसे बनाएं

画像のパレットと主要な色を決定するアプリケーションを作成する方法

이미지의 팔레트 및 주요 색상을 결정하는 응용 프로그램을 만드는 방법

Como criar um aplicativo para determinar a paleta e as cores dominantes de uma imagem

Как создать приложение для определения палитры и доминирующих цветов изображения

Bir Görüntünün Paletini ve Baskın Renklerini Belirlemeye Yönelik Uygulama Nasıl Oluşturulur

Cách tạo một ứng dụng để xác định bảng màu và màu chủ đạo của hình ảnh

如何创建应用程序来确定图像的调色板和主色

Color serves as a fundamental element in graphic systems, particularly in interface design. Alongside form and typography, it constitutes the core of interface design. In this article, we are exploring how a cohesive structure and mathematical principles can streamline color management for designers and developers operating within a design system. To get started, we'll outline the key types of color systems necessary for scaling and enhancing flexibility within a design system. Base Palette This palette encompasses the full spectrum of utilized colors, categorizing them into various tones that range from the darkest to the lightest. At the base color palette level, you establish a system for calculating these tones, thereby contributing to the overall flexibility of the design system. Semantic Structure The semantic palette defines the framework and guidelines for working with colors within the interface. It clarifies the role of color in the interface, making the management of various tones more straightforward. This palette serves as a universal template for creating diverse themes. Theme The semantic structure serves as a template or a set of rules for shaping a theme. A theme, in turn, is a template filled with specific values of variables. It's crucial to emphasize the clear distinction between these two concepts, even though theу are inherently interconnected. A theme lacking a predefined set of rules can hinder the development of other themes and limit flexibility, particularly when it comes to custom or partner themes. Base Color Palette Colors in an interface are remarkably versatile. Although minimalist interfaces may seem to rely on just three colors - light, dark, and accent - a closer examination reveals a rich spectrum of tones. This diverse range of tones serves multiple purposes. Enhancing Interactivity This approach enables you to incorporate interactivity and empower users with control over the system. Different tones of the same color can convey the system's response to user actions, such as pointing and clicking. Managing Hierarchy and Emphasis Within any interface, elements naturally form a hierarchy. Color, combined with dimensionality, can be used to manage and highlight this hierarchy. For instance, important headlines can appear larger and darker in a light-themed design, while secondary text may be smaller and lighter to downplay its significance. Ensuring Accessibility Consider small UI elements as an example - they can benefit from being either lighter or darker to improve readability for users. Smaller elements, in particular, require increased contrast, which makes it necessary to have a variety of lightness tones. The base palette acts as the primary constraint of the variant space, enabling smooth and systematic selection of tones.  For instance, when creating a theme, you can simply utilize the adjacent shade in the palette when determining the hover color for a button (e.g., primary.bg: Marine 400, primary.bgHover: Marine 500). Creating a Base Palette Determine the Number of Tones The average number of tones for a single color in a flexible base palette is around 10 tones. For instance, Google utilizes a palette consisting of 13 tones. Use the HSL Model It is essential to utilize the HSL (hue, saturation, lightness) model alongside mathematical calculations when creating a base palette. The HSL model plays a crucial role in computing the numerical attributes of tones, ensuring alignment in terms of lightness. These calculations, in turn, eliminate the need for subjective selection of tones based on visual assessment and enable the direct calculation of tones at the front.  The HSL model facilitates the management of all three components, although in practice, it is often sufficient to calculate just one parameter, which is lightness. In my work, I also make additional adjustments to the second parameter - Hue. Lightness Lightness plays a fundamental role in generating a variety of color tones. It can be represented using numerical values ranging from 0 to 1000, with 1000 denoting black and 0 denoting white. Employing a step size of 10, you can create 9 distinct tones, excluding pure white and black from this spectrum. Numeric tone names offer a clear and straightforward way to assess any color by indicating its lightness level. For instance, names like "Blue 500" and "Gray 500" immediately signal that these colors share the same lightness parameter. Tip In practice, when creating a color palette, it is often necessary to incorporate intermediate values for both the lightest and darkest tones. Consider using intermediate tones, like 50 (with a lightness parameter of L 95) or 950 (with a lightness parameter of L -5). These tones introduce more subtle variations, thereby enriching your color scheme versatility and its visual appeal. Tip To enhance accessibility in your design, it's recommended to avoid utilizing pure black (hex code 000000) and pure white (hex code FFFFFF) in your color palette. Instead, consider utilizing tone values such as 50 and 25 for white texts when working with dark themes. This approach guarantees that texts remain easily readable and user-friendly, even in low-contrast settings. Hue Another less obvious tip is adjusting the Hue parameter when creating color tones. By doing so, you can achieve a well-balanced color palette that aligns with the way the human eye perceives colors. For instance, in lighter tones, a blue color may visually appear as purple, potentially causing perceptual distortions. By calculating color tones using the HSL model, you streamline the process of developing custom themes for partners or users. This methodology allows you to apply a single formula to create a theme for any color, thereby ensuring consistency and simplifying the theme creation process. Semantic Structure While a broad base palette of tones offers flexibility, employing it for day-to-day design tasks can be challenging. To simplify this process, it's essential to implement a semantic structure or a grouping system that maps a color token to a specific color role. This structure is critical for several reasons: Streamlined Description This approach allows you to specify only the particular set of color tokens used in the existing interface, avoiding the need  to include every color from the extensive base palette and thereby preventing design overload. Promoting Clarity within Teams Semantic structures make color names understandable to both designers and developers, promoting clarity and facilitating collaboration within large teams working on a single project. Universal Template The universal template can be easily customized to create various themes, such as light, dark, or custom themes. Within design systems, color categorization often relies on a single criterion, such as the role of tone in the hierarchy (e.g., accent, primary, secondary). To enhance future theme flexibility, consider introducing additional supplementary criteria for effective grouping. Essentially, the semantic structure should maintain consistency across different themes. This unified approach streamlines the operations with various themes, ensuring both stability and ease of use. Group by Type of Interface Elements Organizing colors based on the category of interface elements is essential for achieving a balance between simplicity and a minimal set of variables. This approach involves categorizing colors into various groups, including: Background Text and Icons Controls Dividers Links These categories collectively cover a wide range of elements commonly found in interfaces. A well-structured naming and grouping system facilitates coordination within large teams and simplifies the onboarding of new team members. When working with multiple variables, striking a balance to maintain design eloquence and consistency when developing themes can be challenging. An insufficient number of variables can impede the eloquence of the design system, while an excess of variables can jeopardize consistency. This concept can be illustrated through a focus state: by describing it within a 'Controls' group once, you eliminate the necessity to describe it separately for each type of interface components. Group Interface Elements by Type: Subgroups When grouping interface elements by type, there's often a need to introduce additional subgroups to achieve a finer level of granularity, especially when handling control states. Group Colors by Role Grouping colors according to their roles is essential for understanding the significance of each color and establishing a hierarchy within your design system. This classification includes the following major groups: Primary Colors Secondary Colors Accent Colors Neutral Colors For instance, accent colors typically serve branding purposes while secondary colors are utilized for supporting elements. Additional Labeling In addition to outlining the hierarchy of color roles,  you may also need to assign labels to define various states.  For instance, within controls,  you should specify states such as "hover," "press," and "disabled." Similarly, you might incorporate additional labels for statuses, such as "success," "error," and "warning." Such labels provide clarity and guidance when working with colors within your design system. Themes Themes have gained increasing importance in recent times, especially with the adoption of both light and dark themes as industry standards. Interface developers face additional challenges when working with custom themes, as it requires a systematic approach. On top of that, it is important to recognize that dark themes aren't merely a direct inversion of light themes. For instance, dark themes might include light-colored input fields. Such cases highlight the necessity for a more nuanced approach to themes within the design system. Summary The universal semantic structure approach offers a robust framework for organizing and managing colors within interface design systems. This method has shown to be exceptionally effective, particularly in large-scale scenarios where your interface or design system is closely affiliated with a partner brand. It can also prove valuable when managing a diverse ecosystem of various products, preventing the entry of numerous smaller design systems. After all, a visual language can be distilled down to three fundamental elements - color, typography, and shape. By utilizing variables seamlessly integrated into a unified template, you can construct a theme suitable for any visual language.

Interface Colors: From Palette to Themes

What's wrong with stickers in Telegram? Deanonymize anonymous channels in two clicks

I chose to share some aspects of my design process, as there is an abundance of fascinating content out there, ranging from general information to specific details. Sometimes, I find it valuable to compare my proсess with others and gain insights from their experiences. This text is a continuation of the previous one, related to the project I am currently working as a solo designer. I recommend that you start by spending 5 minutes reading the first article at the following link to gain more context. https://hackernoon.com/the-implementation-of-design-guidelines-for-small-and-medium-projects?embedable=true In my previous post, I discussed my experience with using design systems. The design development stage is almost finished now that this phase has been completed successfully, and I have recently begun building a website on Framer. Towards the end of the article I plan to write a couple of lines about working with Framer, but I'll go in order. Notable is a company in the engineering field that focuses on chemical product areas. The company has three distinct product lines: metering pumps, chemical pumps, and chemical reagents. The company has built a strong presence in its industry through over a decade of successful operation in the B2B market. The project's current aims include boosting brand awareness and growing the base of loyal customers. The primary issue stems from the company having three distinct operating divisions, each catering to unique target audiences and requirements. In other words, a user searching for specific information may become confused by irrelevant information, making their experience more complicated. Furthermore, the detailed technical information included in product descriptions can make it challenging to organize the visual hierarchy of content and may result in overwhelming the reader with too much information. This is how the issue was initially explained in the project. However, if you dig deeper, you will need to untangle a complex web of various questions. Gain an understanding of the user including their motives for visiting the site, the situations they are in, the questions they ask, and especially what expectations they have from the business. Conversely, the business aims to operate and grow successfully. In essence, you must strike a balance between assisting the user in navigating their current path more efficiently and aiding the business in generating revenue. Highlighting the main benefits of the service and ironing out any potential issues is essential for this task. Every business has its bottlenecks, but it's not always convenient for your client to discuss them. Based on Notable's accumulated experience, the most common ways users find a company's website have been identified: During the design phase of an object, a request is made for a specific technological solution with the involvement of key product components. The user is typically a design engineer with expertise in technology and familiarity with our products. The main benefit for the user is the ease of accessing information and navigation. It is not necessary to provide the full specification, but it is crucial to include specific key elements to ensure the designer fully grasps the requirements. The request has come up because of an unexpected incident at the facility and needs to be resolved quickly. The main focus is on navigation, providing relevant information, and establishing a clear visual hierarchy to simplify the process and guide the user. In this situation, we are not working with a designer, but instead with a manager from the procurement department. And it is probable that his technical expertise concerning the requested product will not be as extensive as it was in the prior situation. The situation occurs when a user is looking for a trustworthy business partner. In this instance, the important values are expertise, reliability, stability and brand awareness. Throughout Notable's operational period, the business has also gone through transformation. The previous top sellers have been replaced by other products. There are new solutions that have surfaced. The company naturally aims to differentiate itself in the market by creating a fresh and distinctive brand identity. In analyzing the industry and the branding of companies within similar fields, it became evident that the color balance is heavily skewed towards shades of blue. After a while, we decided to go with this color palette, which mirrors the gradient in the company logo. I believe that this decision allows us to evoke the appropriate emotions. Additionally, the logo's gradient and depth of color highlight the company's accumulated expertise over the years. Returning to the idea of making navigation easier, I thought about using this gradient on the homepage to smoothly move from hero section to the next until reaching the bottom of the page. Our target audiences vary greatly, so the solution needs to be easily understandable for all. The concept is for the user to scroll through the main page to find the relevant section, select a specific color scheme, such as Purple Heart for chemical reagents, and then continue navigating the site horizontally in this Monochromatic color scheme. The user is greeted by the start screen in Columbia Blue, followed by the dosing equipment block in Medium Purple, chemical reagents in Purple Heart, chemical pumps in Persian, and finally, Indigo tones in the footer. Therefore, the main page was designed with an Analogous color scheme to help users easily concentrate on the content they need. I also added horizontal color palettes to each block using color theory and a better sequence for the user. For instance, when browsing the Purple Heart – chemical reagents pages, the user will stay within the color scheme of the corresponding Monochromatic palette. Website structure. A decision was made to shift from a tree-like structure to a combined, linear one in order to facilitate and accelerate the user's journey. The target pages for the company's top-earning products can now be accessed with just one click. The Bento system made this possible. Cards and an improved visual hierarchy were used to highlight the top products in each Bento block. Therefore, the revised website now consists of just 25 pages, as opposed to the original 61. The achievement was partly a result of the easier-to-use content delivery system and the specific product pages. Therefore, the information architecture on Notable's corporate website now appears as follows: homepage;
Two intermediate pages;
form page;
3 key product pages;
2 service pages;
16 product pages. Three breakpoints were implemented for the main page, intermediate pages, form pages, key product pages, and service pages to ensure a responsive design: Desktop 1200 px, Tablet 1199-810 px и Phone 809 px. On Desktop, the content area is set to 1200 px; I used a simple 12-column grid with a 24 px gutter. The design for Tablet and Phone is completely adaptable. In the end, the design system I developed for this project included: 1389 components;
288 styles;
166 variants. This case is one of those where you don't have enough high quality graphic content. That's just how it turned out. It was necessary to gather everything available, to upscale in some areas, and to attempt to enhance the quality in others. It was challenging to create a large amount of content in Midjourney and other AIs because the neural network is unable to produce technical materials of this quality, this leads to numerous errors and inaccuracies, which quickly and greatly diminish the user's confidence in Notable's expertise. I edited the graphics in Photoshop, incorporated them into a unified color palette, and created the mockups. During my journey, Midjourney has been incredibly useful to me when dealing with abstract graphics representing the movement of liquid. I was fortunate in this instance as I utilized it on the home page start screens, intermediate screens, and the page featuring a key product. The style is consistent, but my main page features a light theme, the product page has a dark theme, and for the intermediate page, as a variation, I animated this abstract flow in Pika. Next I proceeded to construct the website on Framer. Initially, I perceived this stage as a specific challenge due to my lack of experience with Framer. I have experience using different website builders in the past and now have the opportunity to test this one. There is one particular drawback: the expense. Nevertheless, in all other aspects, there are only benefits at this point in time. Usually, one may face several limitations regarding the layout while collaborating with site builders. You have to pursue compromises and depart from the initial design. In the case of Framer, the process involves transferring the layout from Figma with the assistance of plugins, and the use of components is essential. Consequently, this procedure requires a certain amount of time. The animation is generated with minimal effort utilizing only a few mouse clicks. I have a sincere passion for animating layouts in Figma, and I frequently observe a point at which loading speeds noticeably decrease. However, in Framer, any layout is brought to life in a captivating and engaging manner, without requiring a significant time investment. By simply watching a couple of videos from their academy on YouTube, one can quickly gain the skills to enhance dynamic elements. Currently, I will suspend further discussion, and anticipate sharing my impressions following the release in my upcoming post. I chose to share some aspects of my design process, as there is an abundance of fascinating content out there, ranging from general information to specific details. Sometimes, I find it valuable to compare my proсess with others and gain insights from their experiences. This text is a continuation of the previous one, related to the project I am currently working as a solo designer. I recommend that you start by spending 5 minutes reading the first article at the following link to gain more context. https://hackernoon.com/the-implementation-of-design-guidelines-for-small-and-medium-projects?embedable=true https://hackernoon.com/the-implementation-of-design-guidelines-for-small-and-medium-projects?embedable=true In my previous post, I discussed my experience with using design systems. The design development stage is almost finished now that this phase has been completed successfully, and I have recently begun building a website on Framer. Towards the end of the article I plan to write a couple of lines about working with Framer, but I'll go in order. Notable is a company in the engineering field that focuses on chemical product areas. The company has three distinct product lines: metering pumps, chemical pumps, and chemical reagents. The company has built a strong presence in its industry through over a decade of successful operation in the B2B market. The project's current aims include boosting brand awareness and growing the base of loyal customers. The primary issue stems from the company having three distinct operating divisions, each catering to unique target audiences and requirements. In other words, a user searching for specific information may become confused by irrelevant information, making their experience more complicated. Furthermore, the detailed technical information included in product descriptions can make it challenging to organize the visual hierarchy of content and may result in overwhelming the reader with too much information. This is how the issue was initially explained in the project. However, if you dig deeper, you will need to untangle a complex web of various questions. Gain an understanding of the user including their motives for visiting the site, the situations they are in, the questions they ask, and especially what expectations they have from the business. Conversely, the business aims to operate and grow successfully. In essence, you must strike a balance between assisting the user in navigating their current path more efficiently and aiding the business in generating revenue. Highlighting the main benefits of the service and ironing out any potential issues is essential for this task. Every business has its bottlenecks, but it's not always convenient for your client to discuss them. Based on Notable's accumulated experience, the most common ways users find a company's website have been identified: During the design phase of an object, a request is made for a specific technological solution with the involvement of key product components. The user is typically a design engineer with expertise in technology and familiarity with our products. The main benefit for the user is the ease of accessing information and navigation. It is not necessary to provide the full specification, but it is crucial to include specific key elements to ensure the designer fully grasps the requirements. During the design phase of an object, a request is made for a specific technological solution with the involvement of key product components. The request has come up because of an unexpected incident at the facility and needs to be resolved quickly. The main focus is on navigation, providing relevant information, and establishing a clear visual hierarchy to simplify the process and guide the user. In this situation, we are not working with a designer, but instead with a manager from the procurement department. And it is probable that his technical expertise concerning the requested product will not be as extensive as it was in the prior situation. The request has come up because of an unexpected incident at the facility and needs to be resolved quickly. The situation occurs when a user is looking for a trustworthy business partner. In this instance, the important values are expertise, reliability, stability and brand awareness. The situation occurs when a user is looking for a trustworthy business partner. Throughout Notable's operational period, the business has also gone through transformation. The previous top sellers have been replaced by other products. There are new solutions that have surfaced. The company naturally aims to differentiate itself in the market by creating a fresh and distinctive brand identity. In analyzing the industry and the branding of companies within similar fields, it became evident that the color balance is heavily skewed towards shades of blue. After a while, we decided to go with this color palette, which mirrors the gradient in the company logo. I believe that this decision allows us to evoke the appropriate emotions. Additionally, the logo's gradient and depth of color highlight the company's accumulated expertise over the years. Returning to the idea of making navigation easier, I thought about using this gradient on the homepage to smoothly move from hero section to the next until reaching the bottom of the page. Our target audiences vary greatly, so the solution needs to be easily understandable for all. The concept is for the user to scroll through the main page to find the relevant section, select a specific color scheme, such as Purple Heart for chemical reagents, and then continue navigating the site horizontally in this Monochromatic color scheme. The user is greeted by the start screen in Columbia Blue, followed by the dosing equipment block in Medium Purple, chemical reagents in Purple Heart, chemical pumps in Persian, and finally, Indigo tones in the footer. Therefore, the main page was designed with an Analogous color scheme to help users easily concentrate on the content they need. I also added horizontal color palettes to each block using color theory and a better sequence for the user. For instance, when browsing the Purple Heart – chemical reagents pages, the user will stay within the color scheme of the corresponding Monochromatic palette. Website structure. A decision was made to shift from a tree-like structure to a combined, linear one in order to facilitate and accelerate the user's journey. The target pages for the company's top-earning products can now be accessed with just one click. The Bento system made this possible. Cards and an improved visual hierarchy were used to highlight the top products in each Bento block. Therefore, the revised website now consists of just 25 pages, as opposed to the original 61. The achievement was partly a result of the easier-to-use content delivery system and the specific product pages. Therefore, the information architecture on Notable's corporate website now appears as follows: homepage; Two intermediate pages; form page; 3 key product pages; 2 service pages; 16 product pages. homepage; Two intermediate pages; form page; 3 key product pages; 2 service pages; 16 product pages. Three breakpoints were implemented for the main page, intermediate pages, form pages, key product pages, and service pages to ensure a responsive design: Desktop 1200 px, Tablet 1199-810 px и Phone 809 px. On Desktop, the content area is set to 1200 px; I used a simple 12-column grid with a 24 px gutter. The design for Tablet and Phone is completely adaptable. In the end, the design system I developed for this project included: 1389 components; 288 styles; 166 variants. 1389 components; 288 styles; 166 variants. This case is one of those where you don't have enough high quality graphic content. That's just how it turned out. It was necessary to gather everything available, to upscale in some areas, and to attempt to enhance the quality in others. It was challenging to create a large amount of content in Midjourney and other AIs because the neural network is unable to produce technical materials of this quality, this leads to numerous errors and inaccuracies, which quickly and greatly diminish the user's confidence in Notable's expertise. I edited the graphics in Photoshop, incorporated them into a unified color palette, and created the mockups. During my journey, Midjourney has been incredibly useful to me when dealing with abstract graphics representing the movement of liquid. I was fortunate in this instance as I utilized it on the home page start screens, intermediate screens, and the page featuring a key product. The style is consistent, but my main page features a light theme, the product page has a dark theme, and for the intermediate page, as a variation, I animated this abstract flow in Pika. Next I proceeded to construct the website on Framer. Initially, I perceived this stage as a specific challenge due to my lack of experience with Framer. I have experience using different website builders in the past and now have the opportunity to test this one. There is one particular drawback: the expense. Nevertheless, in all other aspects, there are only benefits at this point in time. Usually, one may face several limitations regarding the layout while collaborating with site builders. You have to pursue compromises and depart from the initial design. In the case of Framer, the process involves transferring the layout from Figma with the assistance of plugins, and the use of components is essential. Consequently, this procedure requires a certain amount of time. The animation is generated with minimal effort utilizing only a few mouse clicks. I have a sincere passion for animating layouts in Figma, and I frequently observe a point at which loading speeds noticeably decrease. However, in Framer, any layout is brought to life in a captivating and engaging manner, without requiring a significant time investment. By simply watching a couple of videos from their academy on YouTube, one can quickly gain the skills to enhance dynamic elements. Currently, I will suspend further discussion, and anticipate sharing my impressions following the release in my upcoming post.

Specific Details of the Design Process

Stories, News & Mentions about PADLE

Padle’s Stories on HackerNoon