Circular.Lab

circularlab

This blog assumes that you have a beginner’s knowledge in Flutter. Otherwise, dive into to get the and come right back! basics Now, how do we layout widgets in Flutter? Normally we use a stack, row or column. But what if our requirement is more than that? If we want to arrange some widgets horizontally, we use a Row Widget. If we want to arrange them vertically, we would wrap them in a Column and use Stack to arrange elements on top of another. But we can’t expect our UI to be so simple as that. For example, I was met with a requirement of a circular widget with five equally spaced buttons located on it (check out the image below!). Don’t worry! We can do it with a CustomMultiChildLayout widget which takes only two arguments. CustomMultiChildLayout(delegate: _CircularLayoutDelegate(itemCount: 5,Radius: 150.0,),children: products,) delegate — of type MultiChildLayoutDelegate which is responsible for positioning the children. children — which is the array of widgets to be positioned. The children argument is similar to the one used in rows and columns, but one difference is that every item in that array should be marked with a Layout id for identifying that child. for (int i = 0; i < 5; i++) {products.add( LayoutId(id: ‘BUTTON$i’,child: item,));} Now, the important part is the delegate. The MultiChildLayoutDelegate is an abstract class. So, we have to extend it for our use. Override the method performLayout and we can write the code to position items in it. class _CircularLayoutDelegate extends MultiChildLayoutDelegate {static const String actionButton = 'BUTTON';Offset center;final int itemCount;final double radius; _CircularLayoutDelegate({@required this.itemCount,@required this.radius,}); @overridevoid performLayout(Size size) {center = Offset(size.width / 2, size.height / 2);for (int i = 0; i < itemCount; i++) {final String actionButtonId = '$actionButton$i'; if (hasChild(actionButtonId)) {  
    final Size buttonSize =  
        layoutChild(actionButtonId, BoxConstraints.loose(size));  
    final double itemAngle = \_calculateItemAngle(i);  

    positionChild(  
      actionButtonId,  
      Offset(  
        (center.dx - buttonSize.width / 2) + (radius) \* Math.cos(itemAngle),  
        (center.dy - buttonSize.height / 2) +  
            (radius) \* Math.sin(itemAngle),  
      ),  
    );  
  }}} @overridebool shouldRelayout(_CircularLayoutDelegate oldDelegate) =>itemCount != oldDelegate.itemCount ||radius != oldDelegate.radius ;} The performLayout method gives us the widget’s size from which we can calculate the center of the circle. Since we have to layout five widgets along the circle, use a for loop for it. Remember we have created every item with an id attached to it. So we are using the same id to check whether the item exists or not. Now, size of the button is retrieved using layoutChild method. The angle between the item and center axis is calculated using the function _calculateItemAngle. const double _radiansPerDegree = Math.pi / 180;final double _startAngle = -90.0 * _radiansPerDegree;double _itemSpacing = 360.0 / 5.0;double _calculateItemAngle(int index) {return _startAngle + index * _itemSpacing * _radiansPerDegree;} 6. Finally, positionChild method is called with the id of the item and the offset. The offset is calculated using the mathematical equation, A point at angle theta on the circle whose centre is (x0,y0) and whose radius is r is (x0 + r cos theta, y0 + r sin theta). 7. The shouldRelayout method is called to compare the current layout and the old one and return true if a relayout is needed. So, that’s how easy it is to create custom layouts in Flutter. If you want to read more about our Flutter experience, check out our recent . Flutter has always been our core areas of expertise. So, stay tuned for more similar updates and information exchange! blog You can further learn about our Flutter contributions in . GitHub Originally published at https://www.sayonetech.com/blog/how-create-custom-layout-widgets-flutter/ .

How to Create Custom Layout Widgets in Flutter

Here's How the Pros Choose the Right Load Balancer

HDR or SDR? A Study of Scaled and Compressed Videos: Objective Assessment

Identifying Axion Conversion in Compact Star Magnetospheres With Radio-Wave Polarization Signatures

TO PROVE BY AUTHORITY A PASSAGE TO BE ON THE NORTH SIDE OF AMERICA

Today, mobile phones have become a part of our bodies, making our life so easy and efficient. Everything is under control. It seems that all kinds of U disk viruses and blue screen crash in the PC era have gone forever. In fact, the hardware threats that endanger the security of personal data have never been far away from us (and mobile phones), but we have relaxed our vigilance or are completely unable to distinguish these malicious devices. Next, we introduce five popular hacker hardware tools in 2022 (still). These tools look harmless to humans and animals, but they are powerful. Keyboard injector: automatically execute various commands A keyboard injector is a hacker gadget disguised as a USB flash drive. It integrates reprogrammed USB peripheral malicious firmware. When it is connected to a host computer (including a desktop computer or Android phone), it will be judged as a keyboard by the system. The keyboard injector then sends preloaded keystrokes to the device and performs different FUD (completely undetectable) attacks. FUD attacks can perform the following tasks: Download and execute malware Execute system commands Get the reverse shell Stealing password Hardware keyboard recorder: record every keystroke Software keyboard recorders have long been heard of, but few people can recognize hardware keyboard recorders. It looks like a micro USB adapter or USB flash drive, which can store all keystroke information in our computers and mobile phones. If the keyboard is connected to the host with a hardware keyboard recorder, it can also secretly upload keystroke information to the cloud for storage. The hardware keyboard recorder can store the information of each keystroke, including browsing data, entered passwords, bank details, etc. USB Killer: Burn your computer instantly As its name implies, USB Killer is a very dangerous device, which can not only cause damage to the device but also be very easy to use. USB Killer has been popular for several years. Its principle is to burn the device by releasing high-voltage current circularly. It looks like an ordinary USB device (such as a USB flash disk), but it has a capacitor inside, which can be charged from the power line and bombard the device with high-voltage DC current up to 200V repeatedly until the device is burned out and cannot be repaired. NFC and RFID card readers: Stealing credit cards in space Many daily cards use NFC and RFID (radio frequency identification) to share data, such as access control and door lock cards and credit cards. Hackers can use NFC and RFID card readers to "space" read and clone any card, and then steal or abuse it. This hacker card reader can perform a variety of advanced functions when connected to a PC. The best way to prevent hackers from stealing credit cards or access cards is to put the cards in a card bag or box with an RF shielding function. There are many personal protection products that provide such functions in the market. NetHunter Hacker Mobile Tools: Stealing Secrets by Charging Today, everyone uses smartphones and pays special attention to the security protection of mobile phones. However, few people realize that mobile phones can also be a hacker tool, especially when you need to connect other people's mobile phones to your desktop. In the movies, we see hackers usually hide behind computer screens in dark rooms, but we have never seen them use mobile phones to carry out hacker attacks. In fact, such attacks are more threatening. NetHunter is a mobile penetration test platform that can be installed on Android phones. It has a large number of pre-installed hacker tools, which can turn mobile phones into powerful hacker attack platforms. Suppose you are working in a coffee shop temporarily, and someone asks if you can quickly charge your mobile phone on your laptop. The kind of you may not realize the risk of doing so. However, once the hacker's mobile phone is connected to your laptop to "charge", the hacker can send keystroke instructions to your laptop to perform different tasks, such as setting a back door, stealing passwords, and so on, without even touching his mobile phone (to avoid alerting you).

5 Popular Hacker Hardware Tools in 2022

Instinct

Great Expectations: Chapter VII

Perhaps it is not news to everyone that there are two hard things in Computer Science . I previously explained why I felt because there is some art in doing it . I will not spend any time here arguing whether naming things is an art or not. programming is not boring Instead, I will just go straight into how to name things properly. All the examples below uses the even though the same principles can be applied to other languages. Julia language Why? To me, it is extremely important to write code that is readable and easy to understand. If I write it properly, my colleagues will be able to read it, support it, and enhance it going forward. If I write it badly, I may even curse at myself in the future. I will not cover naming conventions such as or , as they are fairly well documented and understood. Rather, I will focus more about the semantics. CamelCase snake_case As our journey begins... What are the things that we need to give names to? In Julia, the main things are modules, data types, functions, constants and variables. The very first decision is to choose between using a , a , or an . verb noun adjective This is actually not too difficult. One reasonable approach is to adopt the following convention: Naming modules A good module name typically encompasses a group of concepts and functionalities provided by the module. It needs to be broad enough to cover all functionalities but specific enough to distinguish itself from other modules. For example, I have a module that provides an implementation of a circular linked list. I do not name it as , nor would I name it as , for those are too broad of a concept. CircularList LinkedList List Sometimes you want to think bigger and name the module a little broader than what is currently implemented. I think it is appropriate as long as there is a plan to develop the package further, and it does not cause any confusion for any user of the package. But, it should not miss the mark. Additional guidance can be found at the documentation. Julia package naming guidelines Naming data types Data types are used to represent either abstract concepts (abstract types) or concrete data structures (concrete types). That's why using nouns would be appropriate. In the case that data types represent behavior or traits, it is appropriate to use adjective such as and . Iterable Pretty A general rule of thumb is to come up with names that are not too long. I would say any name that is composed of more than three words is . code smell So, is perfectly fine and even is acceptable but would be too long. ProductCatalog ElectronicProductCatalog ElectronicDepartmentProductCatalog Why is it bad? It is because long names are harder to read and spelling mistake are hard to find, causing headaches during debugging. Naming functions For functions, when should I use verbs? And when should I use nouns? There is no hard-and-fast rule. Based upon my experience, I have developed an intuition to make these kinds of judgment. Let me illustrate my thought process with an example. How a noun looks better than a verb... Let's say I am working on an e-commerce site and I have a data type. I want to define a function that determines the price of the product based upon the current market condition. I can think of two names - and . Product current_price calculate_price Now, consider the code below: product products current_price(product) price_range
        add(search_result, product) for in if in end end Does it look better or worse if I choose instead? I bet it would look worse! calculate_price The reason why looks better is that it's easier to read. I can read the code as But, I cannot read the code as " current_price "if current price of the product is in the price range..." if calculate price of the product is in the price range...". Get it? When I use , I'm emphasizing the thing that is being returned from the function rather than how it does its job. current_price At this point, one may argue that the readability issue can be resolved with a temporary variable.  Let's assign the result of the function call to a variable: price product products
    price = calculate_price(product) price price_range
        add(search_result, product) for in if in end end Sure, that could work but obviously it limits the way you write code, so I can't say it's optimal. How a verb looks better than a noun... Next, let's consider the case that I need a new function that find the best price of the product using several different pricing algorithms. So, the pricing function needs to take an algorithm argument. Let's write the function and its corresponding doc string above: current_price(product::Product, algorithm::Algorithm) "Return the current price of the product calculated using the specified algorithm." At this point, it starts to feel just a little more awkward to read. Let's try to use a verb: calculate_price(product::Product, algorithm::Algorithm) "Calculate the price of the product using the specified algorithm." Using a verb makes it more natural when you need to emphasize the action being taken to get the job done. In this example, the use of calculate goes together with the argument algorithm quite well. So, my point is, what do you want to emphasize when calling the function. Is it the thing that it returns, or the process that it goes through? You should be able to make a better decision when you can answer the above question. Naming Constants/Variables I believe the best code should be readable. More often than not, I have heard from other programming experts about using meaningful words for all variables in the code. I can agree to that most of the time, until the verbosity kicks in and kills readability. Religiously. I can think of two examples where it makes sense to use terse names. Doing Math The first case is code that performs heavy-lifting mathematical calculations. It is usually more natural to use math symbols than English words. Julia has and this is an area where it shines. Here's an example from my package: full support of Unicode BoxCoxTrans.jl transform(𝐱, λ; α = , scaled = , kwargs...) α != 𝐱 .+= α any(𝐱 .<= ) && throw( ( )) scaled
        gm = geomean(𝐱)
        @. λ ≈ ? gm * log(𝐱) : (𝐱 ^ λ - ) / (λ * gm ^ (λ - )) @. λ ≈ ? log(𝐱) : (𝐱 ^ λ - ) / λ function 0 false if 0 end 0 DomainError "Data must be positive and ideally greater than 1.  You may specify α argument(shift). " if 0 1 1 else 0 1 end end At current state, the code looks fairly clean and maybe even resembles the formula found in a math research paper. By contrast, it would look very ugly if I have to replace all symbols with names like , , and . alpha lambda time_series Indexing arrays The second case relates to the argument about naming indexing variables such as . I generally oppose this idea. For simple code, it does not matter. For something more complex, it goes against you and hurts readability. index Consider this code that I found from the package: LinearAlgebra rcswap!(i:: , j:: , X:: {<: }) k = :size(X, )
        X[k,i], X[k,j] = X[k,j], X[k,i] k = :size(X, )
        X[i,k], X[j,k] = X[j,k], X[i,k] ## Swap rows i and j and columns i and j in X function Integer Integer StridedMatrix Number for 1 1 end for 1 2 end end Let's just do an exercise and see how it looks if we replace those short variable names with the more meaningful and longer version: rcswap!(index1:: , index2:: , matrix:: {<: }) position = :size(matrix, )
        matrix[position,index1], matrix[position,index2] = 
            matrix[position,index2], matrix[position,index1] position = :size(matrix, )
        matrix[index1,position], matrix[index2,position] = 
            matrix[index2,position], matrix[index1,position] function Integer Integer StridedMatrix Number for 1 1 end for 1 2 end end If the purpose of using longer variable names is to improve readability, then this is doing more harm than good. By contrast, using single-letter variable names is not too bad. In fact, it is quite common that single-letter variable names are used for indexing arrays in any programming language tutorials (e.g. , , , and ). python java javascript rust In addition, whenever I read code, my brain already translates them to read like index. Really, there is no difference between , , or . i j k index They all look the same to me. Wrapping up... Is naming things actually difficult? Definitely, maybe. You may think that I always name things properly? Wrong! I am definitely not perfect. Having written a book and a couple of blog posts, I have come to realize that writing code is no difference from other types of writing in general. You must keep revising (refactoring) to make it right. I do believe that practice makes perfect. I would encourage you to ask someone else to read your code and give you feedback. P.S. For more tips in writing good code in Julia, consider picking up my book Hands-on Design Patterns and Best Practices with Julia .

How to Name Things Properly

Introduction The common goal of feature extraction is to represent the raw data as a reduced set of features that better describe their main features and attributes [1]. This way, we can reduce the dimensionality of the original input and use the new features as an input to train pattern recognition and classification techniques. Although there are several features that we can extract from a picture, Local Binary Patterns (LBP) is a theoretically simple, yet efficient approach to grayscale and rotation invariant texture classification. They work because the most frequent patterns correspond to primitive microfeatures such as edges, corners, spots, flat regions [2]. In [2], Ojala et al. showed that the discrete occurrence histogram of the uniform patterns is a very powerful texture feature. Image texture is defined as a two-dimensional phenomenon characterized by two properties: (1) spatial structure (pattern) and (2) contrast. Fig 1. Image used to test the local binary patterns methodology Methodology Circularly Symmetric Neighbor Set A circularly symmetric neighbor set for a given pixel is defined by the points with coordinates (i, j) that surround the central point on a circle of radius , and a number of elements . gc R P Texture We define a texture as the collection of pixels in a gray-scale image T where corresponds to the gray value of the local neighbor. gp p Interpolation When a neighbor is not located in the center of a pixel, that neighbor gray value should be calculated by interpolation. Thus, we need to define a function that given a coordinate, returns the interpolated gray value. Achieving Gray-Scale Invariance Considering a possible loss of information, it is possible to turn the texture into the joint difference. To calculate it, we subtract the gray value of the central pixel to all of the neighbor set. The joint difference distribution is a highly discriminative texture operator. It records the occurrences of various patterns in the neighborhood of each pixel in a P-dimensional histogram. where is the gray value of the neighbor. This distribution is invariant against gray-scale shifts. gp p Local Binary Pattern operator is by definition invariant against any monotonic transformation of the gray-scale. As long as the order of the gray values stays the same, the output of the operator remains constant. LBP_{P,R} LBP_{P,R} where Uniform Local Binary Patterns In [2], Ojala mentions that in their practical experience LBP is not a good discriminator. They propose just to select the set of local binary patterns such that the number of spatial transitions (bitwise 0/1 changes) does not exceed 2. For example, the pattern ‘1111’ has 0 spatial transitions, the pattern ‘1100’ has 1 spatial transitions and the pattern ‘1101’ has 2 spatial transitions. To each uniform pattern, a unique index is associated. The formula to create the index was borrowed from . here Now, we can calculate the local binary patterns for a central pixel. The next step is to calculate the local binary patterns for all the pixels. Hint: For simplicity sake, I am not considering the case where a selected index is negative (i.e. img_gray[-1][0] returns the last pixel of the first column). If we would want to have a more accurate calculation, we should consider this case and treat it. Cython Code The previous code is not perfect; however, what makes it really slow is that we iterate through all the image pixels. Waiting 1 minute and 10 seconds to calculate our features is a lot if we take into account that we have also to train a pattern recognition technique. Thus, we need an alternative implementation that must be much faster for loops. In this case, we will use Cython. The code is presented in the next image, it is a big chunk of code. Some parts of it could be improved, but it is already much faster. Please feel free to leave comments if you don’t understand something from the code. The code is written in such a way that most of it runs entirely in the C API. This strategy speeds up the execution considerably, but also allow us to take advantage of Cython’s parallel module. We will split the job across multiple cores in the CPU. Using 4 threads, we could calculate the local binary patterns for all the pixels in less than 150 ms. This is so much faster that I won’t even bother to calculate by how many times. Comparison with a Similar Image Let’s take another image of bricks, but this one will have a different texture. Both histograms are very similar, and they should be, in the end both of them are bricks. Nonetheless, features from 20 to 40 are very dissimilar in both images. It means that with a good machine learning algorithm we could correctly classify them. Conclusion Local binary patterns are simple but efficient features. The theory behind is not hard to understand and they are easy to code. Nevertheless, if we code them entirely with Python, we will have some performance issues. We tackled the problem with Cython and we got very impressive results. The next step is to collect different texture images and train your favorite machine learning algorithm to classify them. Jupyter Notebook https://github.com/ocampor/notebooks/blob/master/notebooks/image/features/local-binary-patterns.ipynb Bibliography [1] Marques, O. (2011). Practical image and video processing using MATLAB. John Wiley & Sons. [2] Ojala, T., Pietikäinen, M., & Mäenpää, T. (2002). Multiresolution gray-scale and rotation invariant texture classification with local binary patterns. IEEE Transactions on Pattern Analysis and Machine Intelligence, 24(7), 971–987.

Stories, News & Mentions about CIRCULARLAB

Categories

Trending Topics

Stories, News & Mentions about CIRCULARLAB

Circularlab’s Stories on HackerNoon

Categories

Trending Topics