sharpening | Example processing block showcasing how raster | Computer Vision library

Does the application just launch dotnet build command as a process?

If you want it to do a build of a .NET Core / .NET 6 application, sure. Generally this is configurable and it's not uncommon for them to install the dependency as part of the build now so whoever installs the application doesn't have to rely on installing the tools manually.

Should I just launch git command as a process to download source code? Given, code resides in got only.

It's either that or embed a Git library into your application and figure out how to call it. Info here.

Are there options apart from launching external process?

An application that acts as a build server just calls other tools in another process usually. You can embed some libraries and try to code some features yourself, but I would rely on calling those tools from your application. The point of a build server is for the steps to be replicable.

You want a series of steps that can be reproduced on another machine and produce the same results. Different versions of your application (for the most part) shouldn't end up with different results and they won't assuming you're relying on the external tools themselves. Doing this allows you to have feature parity with what a developer would do on their local machine running the commands.

I'm pretty sure you are seeing some value overthrow. I do not understand exactly why this works, but dividing the kernel by 255 and setting the initial image as a float yielded the correct result :

As is being pointed out, one needs to distinguish between first derivatives (edges) and second derivatives (ridges, peaks).

You don't talk about it but you link to an article on "unsharp masking". That is supposed to use a difference of gaussians... which is close to a laplacian (... of gaussian). Not quite the same, but practically the same.

That means you don't actually deal with edges but with ridges/peaks.

As for the kernels and their signs... Wikipedia is being mysterious and misleading as usual.

They subtract a laplacian because they have to. The laplacian has a negative response to peaks/ridges. Conceptually, you do add an edge/ridge detection filter... if it were one.

The kernel you see looks like an upside-down mexican hat. It's a "laplacian of gaussian". That means it's the second derivative of a gaussian kernel. As a second derivative, it responds negatively to a positive peak/ridge, e.g. of the gaussian.

Here's a plot of a gaussian and its first and second derivatives:

Since you'd expect a ridge/peak detection filter to have a positive response to a positive ridge/peak, you'd use the negated second derivative, and add that.

Look at these pictures:

1: 2: 3:

1. the [-1 +5 -1] kernel, i.e. identity - laplacian = identity + filter
2. the picture itself
3. [+1 -3 +1] kernel, i.e. identity + laplacian = identity - filter

You see, #3 looks blurry because some high frequencies were subtracted.

The text gets 'stretched' because you setup for a 40-columns screen! You've written:

1. Use standard library functions memcpy, memmove, etc as they are very optimized for your platform.
2. Use the correct type for sizes - size_t not int

There are few issues I was able to identify:

• The edge image is allowed to have both positive and negative values.
  Remove the abs, and remove the if edge_pad[i, j] < 0...
• The "window" img_pad[i:i + 3, j:j + 3] is not centered around [i, j], replace it with:
  img_pad[i-1:i+2, j-1:j+2].
  (Look for 2D discrete convolution implementations).
• I think w in the formula is supposed to be a negative scalar.
  Replace w = np.array([1, 1.2, 1]) with w = -1.2.
• The type of t1 and edge_pad is np.float64, and the type of img is np.uint8.
  The type of img - edge_pad[1:edge_pad.shape[0] - 1, 1:edge_pad.shape[1] - 1] is np.float64.
  We need to clip the values to range [0, 255] and cast to np.uint8:
  out_img = np.clip(out_img, 0, 255).astype(np.uint8).

I can't see any issues regarding .raw format.
I replaced the input and output with PNG image format, and used OpenCV for reading and writing the images.
The usage of OpenCV is just for the example - you don't need to use OpenCV.

Here is a "complete" code sample:

Try and set the encoding to UTF-8

For example:

file = open(filename, encoding="utf8")

For reference check this post:

UnicodeDecodeError: 'charmap' codec can't decode byte X in position Y: character maps to

The filters argument sets the number of convolutional filters in that layer. These filters are initialized to small, random values, using the method specified by the kernel_initializer argument. During network training, the filters are updated in a way that minimizes the loss. So over the course of training, the filters will learn to detect certain features, like edges and textures, and they might become something like the image below (from here).

It is very important to realize that one does not hand-craft filters. These are learned automatically during training -- that's the beauty of deep learning.

I would highly recommend going through some deep learning resources, particularly https://cs231n.github.io/convolutional-networks/ and https://www.youtube.com/watch?v=r5nXYc2wYvI&list=PLypiXJdtIca5sxV7aE3-PS9fYX3vUdIOX&index=3&t=3122s.

I found my solution by getting almost every setting of panel graphics and applying them to buffered image graphics. Here, the importing thing is that the panel's graphic scales everything by 1.25 and then scales down to the original before showing it on the panel.

Here is an example, -this is not exactly how my code is, this is just an example to give you an idea-