FindColor | A small toy written by myself two days

You're going to want to use some kind of Timer with a callback, to move the mouse incrementally, step by step. As for the movement itself, you have a world of possibilities, but it's all maths.

So, let's decompose the problem.

It doesn't necessarilly looks like it, but when you move your mouse, you're simply setting its position multiple times per seconds.

The amount of times the position changes per second is equivalent to the polling rate of your mouse. The default polling rate for USB mice is 125Hz (or 125 position changes per second, if you will). This is the value we'll use for our Timer: its callback will be called 125 times per second.

You can use simply use Object.keys and filter

Hope this helps, you can try it;

Name your method

In addition to the typo, the param to the find argument is an object with color_family:

I discovered the (silly) mistake I was making.

The pixel coordinates returned by QMouseEvent::pos() start at the upper left corner, while those accepted by glReadPixels start at the lower left corner.

So, changing the call to glReadPixels in mousePressEvent this way

There are multiple issues with your code leading to multiple different problems then. So answer will be little bit lengthy.

First to how a Excel workbook is structured:

A workbook consists of at least one but maybe multiple sheets each having multiple rows each having multiple cells. Each cell may have style. But the style settings are not stored in the cell but in a style sheet (styles table) on workbook level. Thus styles are stored across cells, rows and even sheets. Multiple cells may share the same stored style if they have the same look. Same is for colors. Colors also are stored on workbook level. And unfortunately in *.xls BIFF format colors are limited to indexed colors within a color palette. In BIFF8 there are 49 (index 16 to 64) in user-defined PALETTE record plus some single more. Those 49 can be overwritten but count cannot be increased.

Now to your code:

You are writing out the whole workbook every time you have changed a cell in a row of a sheet. You should not do so. Instead you should writing out the workbook once if you are finished with it.

You are creating a new cell style for every cell you needs putting style on. You should not do so. Excel *.xls is limited to approximately 4,000 different combinations of cell formats. So you need checking whether the style you are needing not is already present in the workbook. This can be very tedious but there is CellUtil, which you have found already and do using in your code already. This provides setCellStylePropertieswhich "attempts to find an existing CellStyle that matches the cell's current style plus styles properties in properties. A new style is created if the workbook does not contain a matching style.".

You are first searching whether a needed color already exists. That's good. But if not, you are overwriting always the same color index of color GOLD. Since colors also are stored on workbook level, only the last overwritten color value will be stored as GOLD. You need overwriting different color indexes if different colors shall be stored in workbook.

Example:

Source Excel:

Code:

hBitmap = (HBITMAP)SelectObject(hdcMemory, hBitmapOld);

That's going to overwrite hBitmap, you don't want that. You should change that line to:

First thing to do - profile (measure time consumption of different parts of your function). It often shows that time is spent in some unexpected place, and always suggests where to direct your optimization effort. It doesn't mean that you have to focus on that most time consuming thing though, but it will show you where the time is spent. Unfortunately I'm not familiar with Swift so cannot recommend any specific tool.

Regarding iterating through all pixels - depends on the image structure and your assumptions about input data. I see two cases when you can avoid this:

1. When there is some optimized data structure built over your image (e.g. some statistics in its areas). That usually makes sense when you process the same image with same (or similar) algorithm with different parameters. If you process every image only once, likely it will not help you.

2. When you know that the green pixels always exist in a group, so there cannot be an isolated single pixel. In that case you can skip one or more pixels and when you find a green pixel, analyze its neighbourhood.