Because some scoring clusters may not be relevant, we may want an API to avoid those clusters included to score

GLCM hasn't been verified to work correctly yet, will need a test with verified workings

We can include default sample images here in Frame2D format if possible

Example

We do a mask of label 1, do a hist, if the hist of label 1 and 2 overlap, it's not a good predictor

https://scikit-learn.org/stable/auto_examples/cluster/plot_dbscan.html#sphx-glr-auto-examples-cluster-plot-dbscan-py

As per #19

glcm_view resets at the wrong location

for wi_c in prange(wi_cols, nogil=True, schedule='dynamic'):
	glcm_view[:] = 0
	for w_ch in prange(w_channels, schedule='dynamic'):
		for w_r in prange(w_size, schedule='dynamic'):

should be moved into

for wi_c in prange(wi_cols, nogil=True, schedule='dynamic'):
	for w_ch in prange(w_channels, schedule='dynamic'):
		glcm_view[:] = 0
		for w_r in prange(w_size, schedule='dynamic'):

Every channel has their own glcm_view, currently, the 2nd, 3rd channel is building upon the entropy every cycle

https://scikit-learn.org/stable/modules/generated/sklearn.metrics.completeness_score.html

As per #19, I ran a test, and found that

cor = (conv_ab - (conv_ae - conv_be)) / conv_stda * conv_stdb

has bracket error on conv_stda * conv_stdb and (conv_ae - conv_be) should be multiplied by the number of cells due to early convolution broadcasting.

cor = (conv_ab - (conv_ae - conv_be) * (2 * radius + 1) ** 2) / (conv_stda * conv_stdb)

Due to problems with extending np.ndarray, we'll just stuff everything into Frame2D.

While it does look like it's messy, its API so far has been pretty good. I'll keep this in view though.

Currently, I'm defaulting anything that results in a neginf or posinf to be -1, 1 respectively. This is based of the vanilla definition of correlation, where it's bounded by -1 and 1.

Considering the context of GLCM, it is a reasonable replacement?

Just in case I forget.

Rescale Correlation to -1 ~ 1
Rescale Entropy to 0 ~ 1

as per

e694b1d
bc95091

Through labelling certain centroids by professionals, we can construct a n-Dimensional Ellipsoid to Cluster some points.

The ellipsoid shape, instead of a spherical shape, is to account for the axis transformation to emphasize/loosen the strictness of the clustering in a certain axis.

If we can somehow detect the corners of trees, we may get something interesting

0 0 1
0 1 1
1 1 1

Currently, GLCM works by offsetting the image by a set step.

Concerns being that the texture analysis in a very small unit may be drastically affected by noise during capturing, possibly reducing effectiveness of GLCM.

There can be tests to determine if scaling down an image produces better GLCM. The scaling can be done using gaussian convolution or just a flat ones convolution.

Proposing this to be explored in 0.0.6 or 0.0.5 if possible

GLCM can be just counted, or normalized.

Normalized GLCM is just the count/len. Likely wouldn't add too much algorithmic load on normalization in GLCM2D.

There's a lot of functions that uses implied indexes such as data_rgb which just takes the first 3 indices.

We can improve this integrity by specifying the underlying datum indices.

Either:

Plan 1

data: np.ndarray
_ixs: dict = {"R": 0, "G": 1, ...}

Plan 2

data_r: np.ndarray
data_g: np.ndarray

Note that Plan 1 may be prone to unintended _ixs editing or bad _ixs. While Plan 2 requires a lot of overhaul in input and output methods.

We'll look into this later

_frame_kmeans.py

        frame_xy_trans = scaler(self.data_flatten()[:, fit_indexes])

doesn't seem right

flatten, then get a 2nd dimension?

Instead of having to guess which numeric index is which calculated index, we can probably add a small overhead in each Frame to determine the locations

Because the GLCM uses a sliding window, there are values overlapping, hence we could somehow reuse those values?