codified | main application of this library

The , in your subsetting should likely be a logical (& or |).

Options:

^{Note: this answer does not directly reply to the question, since the origin of the problem was not related to the scrollbars}

The problem is caused by the fact that setHtml always resets the contents. While the result might appear instantaneous, it is not, since the document has to be layed out again based on the size of the scroll area, which eventually updates the scroll bars.

While technically it is possible to delay the scrollbar reposition, the real issue is that setHTML is not the proper way to provide highlighting, especially for mouse hovering: every single individual movement of the mouse would cause what explained above, and this is clearly not a good solution, performance wise.

It's also important to remember that setting the HTML in a Qt editor is only interpreted, since the HTML is parsed and then "translated" into a Qt document; you'll see that toHtml() will not return the code used for setHtml(), even if no change has been made.

In fact, the proper way to alter the format of a Qt rich text editor, is to interact with its lower level API, accessing the QTextDocument and modifying it using a QTextCharFormat.

Note that while normal editing is applied using the QTextCursor interface, it would not be effective for this purpose, since it is considered as an "user action" and adds the format change to the undo stack of the document.

In order to apply changes to the underlying document without changing its contents, it's necessary to use the QTextLayout of the QTextBlock that will contain the highlighted text, then it's possible to create and set a FormatRange for that layout by specifying the character boundaries and actual format.
This approach has the benefit that the format changes do not change the actual document formats, but only the way the document is displayed, so, for instance, toHtml() will never include the highlighting.

This is the summarized procedure:

1. get the QTextCursor based on the mouse cursor position;
2. select the word under the mouse;
3. get the QTextBlock and ensure that the mouse is actually inside the rectangle of that block (cursor.WordUnderCursor always finds the closest word, even if it's not exactly under the mouse);
4. get the range of the selection and check if the range is changed from the previous call;
5. clear the previous layout format (it could be a different word or even a different block);
6. if there is a selection, create a FormatRange with the start position based on the block cursor position, and with a given text format;
7. set the format on the layout;
8. notify the document that its contents are "dirty" and need to be layed out again (and repainted);

In order to call the function whenever the mouse moves, the mouseTracking property should be set, and the viewportEvent must be overridden to properly track mouse events.

Orion restricts the usage of some characters due to security reasons (script injections attack in some circumstances), see this piece of documentation. In particular, the = you have in the password attribute value.

You can avoid this, for instance, by encoding the password in base 64, or using URL encoding before storing it in Orion.

Another alternative using TextUnrestricted in attribute type. This special attribute type does not check if the attribute value contains a forbidden character. However, it could have security implications, use it at your own risk!

You can define the axis you want to calculate the norm on with np.linalg.norm.

For example, here the norm of the first three-channel pixel of the 1st image of 1st window:

I don't get why you are doing ALL(Rechazos) and then applying the filters again, but probably your error can be fixed by saving the last load into a variable:

IDA* is one of the best algorithms for solving the Rubik's cube because the state space is large and there aren't very many duplicates if you do proper move pruning. To get an efficient solver you need move pruning and good heuristics. Typically there are three moves per face - 90 degrees forward/backwards and 180 degrees. With 6 faces there are 18 moves.

1. Simple move pruning: If you do some simple pruning of your moves by keeping one move of history, you can shrink the branching factor of Rubik's cube from 18 to about 15. Because any single move can get a single face into any configuration, you should never move the same face twice in a row. After the first move, there will be 5 faces with 3 moves each = 15 moves at each step.

2. Advanced move pruning: Let three of the faces be "first" faces, and three of them be "second" faces, where the second faces are opposite the first faces. Here the rule is that after you move a first face, you can move any of the other faces - so there will be 15 moves. But, after you move a second face, you can't move the same face again or the opposite first face. In this case the branching factor is 12. The overall branching factor is then around 13.

3. Heuristics: Pattern Databases (PDBs) make good heuristics for Rubik's Cube. What you do is, for instance, ignore the edges and then exhaustively solve all corners, store the results in a hash table. (Use a perfect hash function and then there will be a unique compact mapping which is very memory efficient.) There are 88 million combinations and less than 16 values, you can store this in 44 MB of memory. When you want the heuristic for a state, you then just use the hash function to look up the corner configuration in the table, which contains the total number of moves required to solve that configuration. That is an admissible (and consistent) heuristic for the problem. On top of this you might want to do the edges, but the 12-edge PDB takes 500GB of memory to store and might not fit in memory. So, you can do subsets of edges. You can also use cube symmetries and many other tricks to get better heuristic values. But, with a good parallel IDA* implementation and some large PDBs you can solve random Rubik's cube instances optimally.

There are a lot of research papers on the topic - I suggest using Google scholar to look them up online.

If you want to start with something simpler, here is how you can implement a "simpler" heuristics:

1. For each corner/edge in the cube, compute how many moves it will take to get to the goal position/orientation all on its own. Add this up over all cubes.

2. Since each turn of a face of the cube moves 4 corners and 4 edges, take the number from the first step and divide it by 8. This is then an admissible heuristic for the problem.

If you ignore the orientation, it will take at most two moves for each cube to reach its goal position, meaning your final heuristic will be less than 2. Taking orientation into account will only raise this slightly. So, this approach will not be particularly effective in practice.

you can bitshift and sum your numbers: