Matplotlib

You can use a 2D FFT to find the general direction in which the crop is aligned (as proposed by mozway in the comments). The idea is that the general direction can be easily extracted from centred beaming rays appearing in the magnitude spectrum when the input contains many lines in the same direction. You can find more information about how it works in this previous post. It works directly with the input image, but it is better to apply the Gaussian + Canny filters.

Here is the interesting part of the magnitude spectrum of the filtered gray image:

The main beaming ray can be easily seen. You can extract its angle by iterating over many lines with an increasing angle and sum the magnitude values on each line as in the following figure:

Here is the magnitude sum of each line plotted against the angle (in radian) of the line:

Based on that, you just need to find the angle that maximize the computed sum.

Here is the resulting code:

try something like this:

Many matplotlib functions follow the color cycler to assign default colors, but that doesn't seem to apply here.

The following approach loops through the generated annotation texts (artists) and the clf tree structure to assign colors depending on the majority class and the impurity (gini). Note that we can't use alpha, as a transparent background would show parts of arrows that are usually hidden.

If the hyperspectral dataset is given to you as a large image with many channels, I suppose that the classification of each pixel should depend on the pixels around it (otherwise I would not format the data as an image, i.e. without grid structure). Given this assumption, breaking up the input picture into 1x1 parts is not a good idea as you are loosing the grid structure.

I further suppose that the order of the channels is arbitrary, which implies that convolution over the channels is probably not meaningful (which you however did not plan to do anyways).

Instead of reformatting the data the way you did, you may want to create a model that takes an image as input and also outputs an "image" containing the classifications for each pixel. I.e. if you have 10 classes and take a (145, 145, 200) image as input, your model would output a (145, 145, 10) image. In that architecture you would not have any fully-connected layers. Your output layer would also be a convolutional layer.

That however means that you will not be able to keep your current architecture. That is because the tasks for MNIST/CIFAR10 and your hyperspectral dataset are not the same. For MNIST/CIFAR10 you want to classify an image in it's entirety, while for the other dataset you want to assign a class to each pixel (while most likely also using the pixels around each pixel).

Some further ideas:

• If you want to turn the pixel classification task on the hyperspectral dataset into a classification task for an entire image, maybe you can reformulate that task as "classifying a hyperspectral image as the class of it's center (or top-left, or bottom-right, or (21th, 104th), or whatever) pixel". To obtain the data from your single hyperspectral image, for each pixel, I would shift the image such that the target pixel is at the desired location (e.g. the center). All pixels that "fall off" the border could be inserted at the other side of the image.
• If you want to stick with a pixel classification task but need more data, maybe split up the single hyperspectral image you have into many smaller images (e.g. 10x10x200). You may even want to use images of many different sizes. If you model only has convolution and pooling layers and you make sure to maintain the sizes of the image, that should work out.

You're using outdated imports for tf.keras. Layers can now be imported directly from tensorflow.keras.layers:

I'm not sure if this is possible if you're linearly scaling the image. However, you could give OpenCV's Contrast Limited Adaptive Histogram Equalization a try:

• The default pkgs/main channel for conda has reverted to using freetype 2.10.4 for Windows, per main / packages / freetype.
• If you are still experiencing the issue, use conda list freetype to check the version: freetype != 2.11.0
  • If it is 2.11.0, then change the version per the solution, or conda update --all (providing your default channel isn't changed in the .condarc config file).

• If this is occurring after installing Anaconda, updating conda or freetype since Oct 27, 2021.
• Go to the Anaconda prompt and downgrade freetype 2.11.0 in any affected environment.
  • conda install freetype=2.10.4
• Relevant to any package using matplotlib and any IDE
  • For example, pandas.DataFrame.plot and seaborn
  • Jupyter, Spyder, VSCode, PyCharm, command line.

• An issue occurs after updating with the most current updates from conda, released Friday, Oct 29.
• After updating with conda update --all, there's an issue with anything related to matplotlib in any IDE (not just Jupyter).
  • I tested this in JupyterLab, PyCharm, and python from the command prompt.
  • PyCharm: Process finished with exit code -1073741819
  • JupyterLab: kernel just restarts and there are no associated errors or Traceback
  • command prompt: a blank interactive matplotlib window will appear briefly, and then a new command line appears.
• The issue seems to be with conda update --all in (base), then any plot API that uses matplotlib (e.g. seaborn and pandas.DataFrame.plot) kills the kernel in any environment.
• I had to reinstall Anaconda, but do not do an update of (base), then my other environments worked.
• I have not figured out what specifically is causing the issue.
• I tested the issue with python 3.8.12 and python 3.9.7
• Current Testing:
  • Following is the conda revision log.
  • Prior to conda update --all this environment was working, but after the updates, plotting with matplotlib crashes the python kernel

First of all: The results here when I tried the code is different then what you displayed in the question.

Let's say we have a gray scaled picture. Each pixel would have a value of integers between [0, 255]. Sometimes these values can be floats between [0, 1].

Here 0 is black and 255 is white. The vales between (0, 255) are grays. Towards 0 it gets more gray, towards 255 its less gray.

(I'm not sure about the term Polychromatic) Colored pixels are not so different then gray scaled ones. The only different is colored pixels storing 3 different values between [0, 255] for each Red, Green and Blue values.

see: https://www.researchgate.net/figure/The-additive-model-of-RGB-Red-green-and-blue-are-the-primary-stimuli-for-human-colour_fig2_328189604

Now let's see what what the image you are creating is like:

You are crating a matrix of zeros with shape of: 256, 256 * 6, 3, which is: 256, 1536, 3.

Then with the first line you are replacing the first column with something else:

• using your sample data for points
• these points are in Saudi Arabia, so assumed that polygons are regional boundaries in Saudi Arabia. Downloaded this from http://www.naturalearthdata.com/downloads/10m-cultural-vectors/
• polygon data is a shape file
  1. loaded into geopandas to allow interface to GEOJSON __geo__interface
  2. dynamically filtered this to Saudi using pandas .loc
• confidence data is just a straight https://plotly.com/python/mapbox-density-heatmaps/
• boundaries are https://plotly.com/python/mapbox-layers/