10
This is the classic colorization using optimization problem.
Optimization and Linear Algebra
To see how this can be expressed as a linear system, it's helpful to use a slightly different notation (and a slightly different objective function). Think of your image as graph $G$ with a node for each pixel in the image. There is an edge $(i,j)$ between two ...
9
There are a lot of ways to speed up convolution is specialized contexts, e.g.:
If your filter is separable, i.e. $h = h_1 * h_2$ with $h_1\in\mathbb{R}^{n\times 1}$ and $h_2\in\mathbb{R}^{1\times m}$, calculating $(u*h_1)*h_2$ is much faster than $u*(h_1*h_2)$.
Convolving with $h = [1\ \dots\ 1]$ (for any length) can be done recursively with basically two ...
7
A convolution becomes a product if you apply it in Fourier space, so you can express the operation $I * m$ ($I$ being the image, $m$ being the mask with which you filter) as $I * m = F^{-1}(F(I) \cdot F(m))$ (where $F$ is the Fourier transform) which will cost you $O(MN \log (MN))$ operations. Whether this is cheaper than what you have depends on the size of ...
6
I believe the best approach here is to use a threshold based on the local average brightness of the image. Setting the threshold to be 90% of the mean value of the 11x11 grid surrounding each pixel gives results that are about as good as you can expect with such a low resolution image.
For each pixel you just need to compute the mean brightness of the ...
5
Continuous
It looks like you only need 2d curl, so let's start with a simpler continuous definition:
$$ \omega = \nabla \times \mathbf{u} = \frac{\delta v}{\delta x} - \frac{\delta u}{\delta y}
$$
where 2d vector field $\mathbf{u}=(u,v)$ (same as your $\mathbf F = (F_1,F_2,F_3)$, dropping $F_3$). Note that curl is a vector and in the 2d version, and is ...
5
Short answer: No.
You have a number of options here.
For your NVIDIA GPU, you will get the best performance by switching to CUDA, rather than OpenCL. You can also upgrade your card, to something like the Geforce Titan, which significanty outperforms the Quadro card for GPU computation.
My personal opinion is that CUDA is much nicer to work with, has ...
5
I have to tell you.
I implemented this algorithm (even double checked with other experienced people), however no luck. I guess, this worked for the authors, but with our data there was really no improvement.
Additionally, once upon a time, the authors provided a code. I also tried it on my own dataset. Again, didn't work. Therefore, I am now sure that this ...
4
How about something like radial integral channel features?
Affordable person detection in omnidirectional cameras using radial integral channel features, Barış Evrim Demiröz, Albert Ali Salah, Yalin Bastanlar, Lale Akarun, Machine Vision and Appliactions 2019
https://www.cmpe.boun.edu.tr/~salah/demiroz19omnidirectional
They would allow you to:
Specify ...
4
Morphological Closing.
A morphological closing is a combination of dilation followed by erosion; typical image processing operations available in most image processing libraries.
SciPy has a "simple" binary closing method which does this on binary images. By experimenting with different structuring elements you can close smaller or bigger gaps.
4
Take a look at the literature that does similar things for facial recognition -- search for the term "eigenface", for example.
The point to make in this context is that the information you are looking for does not actually require you to consider high-resolution images. You may have $10,000\times 10,000$ pixels, for which any non-trivial ...
3
PSNR, the ratio between the peak power of the true signal and the power of
the Gaussian noise, measures the amount of mathematical error introduced in an
image by compression or noise introduction. This would be ideal for your evaluations.
PSNR is related to MSE (mean squared error) but uses a logarithmic scale. PSNR between a grayscale image $A$ and its ...
3
Awesome to find another microscopist on this site. Welcome!
Short Answer:
There is no magic-bullet on the market that will solve this problem space for you.
Longer Answer:
Putting together a few commercailly available offerings gets you pretty far.
At my work we take ~1-10 thousand $4\,096\times25\,000$ images weekly, which puts us in a similar ...
3
The quantity you are measuring currently is something akin to "prominence" which is a better formed topographical quantity than numerical one. The wiki page in that link describes all sorts of strange cases that arise, even without having any image/surface borders to worry about.
If you want to stick with this alignment metric I would suggest using a ...
3
I think I can address the second part of your Question.
The phrase "sum-normalized to zero" is a fancy way of saying "subtract the mean (average)", i.e. subtract the constant needed to give a zero sum over the resulting function (filter) values.
The phrase "square-normalized to 1" applies to the result of the first phrase and means dividing by a (...
3
We construct an operator based on the assumption that the system is a linear space invariant system. The blurred image is denoted $b$ and the input is denoted $x$.
Since the convolution is commutative, we can write
$
\begin{align}
b &= h*x\\
&=x*h
\end{align}
$
So we can have two equal representations using the matrices $H$ and $X$ corresponding to ...
2
You may interpret both images as individual clustering problems: You can then calculate an a posteriori probability of beeing marked/ blood vessels.
In case both images are properly aligned, you may now calculate a distance measure between the two matrices of a posteriori probabilities. A common distance measure is the Kullback-Leibler divergence.
2
You can optimize the convolution, using separable theorem. Let me give an example.
Image ($M\times N$): 1024, 768 (Grayscale)
Convolution mask ($k\times k$): 7x7
Computational complexity: Convolution -> $O(MNkk)$
Computational complexity: Separable convolution -> $O(2*MNk)$
being k = kernel size.
Using normal convolution you got O(1024*768*7*7) = ...
2
There are two different ways to extent cubic splines to 2D.
The more official approach is the tensor product approach. On the boundaries where $x$ is constant, you require $S_{xx}=0=S_{xxy}$. On the boundaries where $y$ is constant, you require $S_{yy}=0=S_{xyy}$. The condition $S_{xxy}=0$ can be derived from $S_{xx}(x_0,y)=0\ \forall y$.
The less official ...
2
You might be able to do better than simple gradient descent using an algorithm like BFGS, which uses the history of the gradients as well as the approximate solutions to try and approximate the Hessian of the objective functional. A good explanation of how the algorithm works, modifications for large systems, modifications in the event of non-convexity, etc. ...
2
EDIT: some code made available] From a personal experience, and in the work of colleagues, we observed that multi-band dual-tree wavelets, a type of low-redundancy oriented decompositions based on Hilbert pair of wavelets, were an interesting alternative to higher redundancy transformations (curvelets, shearlets). You can have a two-fold or four fold ...
2
This is made a lot easier by introducing the Calculus of Finite Differences.
If $u_{i,j}$ is grid function defined for integer $i,j$ then the y-differencing operator
$$\delta_y u=u_{j+1}-u_j$$ is defined at $i,j+1/2$, so no need to write indices. Similarly, $$\mu_xu=(u_{i,j}+u_{i+1,j})/2 $$ is the x-averaging operator and is defined at $i+1/2,j$. We ...
2
Sounds like a job for the Earth Mover's Distance (or Wasserstein metric).
In computer science, the earth mover's distance (EMD) is a measure of the distance between two probability distributions.
Informally, if the distributions are interpreted as two different ways of piling up a certain amount of dirt over the region $D$, the EMD is the minimum cost of ...
2
As I mentioned before, you can try with the Visible Human Project.
You can also go with 3D Slicer sample data, e.g., the Knee Atlas or the Brain Atlas. Their terms are quite permissive:
By downloading these data, you agree to acknowledge our contribution in any of your publications that result form the use of this atlas.
There is also OpenfMRi, but you ...
2
Writing my comment idea in more detail: Lets say you have your image input to your application as a black and white pixel array, for example something like:
Then each black pixel can be represented with a 1 and each empty white pixel represented with a 0. The corresponding array would look like:
\begin{array}{c c}
0 & 0 & 1 & 1 & 0 & ...
2
You would greatly benefit from knowledge in signal processing, but some specific useful knowledge would be in computer vision and estimation (like Kalman filters or alpha beta filters).
With respect to tracking blobs, you could use blob detector algorithms to find meaningful blobs, use some descriptor like SIFT to describe the blob and then do feature ...
2
There are several alternatives:
Alternative #1: you need to find for each cell of the tessellation the list of pixels contained in the cell. To do that, you can use a rasterization algorithm. You can use my open-source implementation [1]. If performance is an issue, you can also do that with a GPU.
Alternative #2 (the simplest): (if you have many different ...
2
For an operator $R$ to be linear, it has to satisfy two conditions:
$R(f+g) = Rf + Rg$ for any two operands $f,g$;
$R(\alpha f) = \alpha Rf$ for any operand $f$ and (real or complex) number $\alpha$.
This is true for the Radon transform, as one easily verifies. Whether compressed sensing can be applied to it is something beyond my realm of knowledge.
2
You may start with median or Gaussian filters. There are many libraries that implement them and they are simple to use.
That said, I think this approach may be not enough because from what I've seen this noise is not an image noise in the classical sense, i.e. it's not randomly distributed 'dots', but rather periodic 'waves' and their presence is connected ...
2
I think that you could use a Gaussian Filter.
The following Python code does something similar to what you show in your images.
from __future__ import division
import numpy as np
from scipy.ndimage.filters import gaussian_filter, laplace
import matplotlib.pyplot as plt
y, x = np.mgrid[-2:2:101j, -2:2:101j]
z = np.maximum(0, 0.2 - (x + 0.5)**2 - y**2) +\
...
2
They just curve fit the two equations
$$
x(\omega) = h - b \sin(\omega) ~,~~
y(\omega) = k + a \cos(\omega)
$$
using a nonlinear curve fitting algorithm. However, the accuracy of the fit depends on the choice of algorithm and you have to be careful to make sure that $a$ and $b$ are always positive (by adding constraints).
One way of approaching the ...
Only top voted, non community-wiki answers of a minimum length are eligible
