Picking multiple objects from background

[anvoice]

Hello,
Quick version:
Does anyone know of any image processing libraries/techniques that can pick out shapes from a background accurately, even given significant gradients of brightness between different shapes, and a gradually changing background?

Detailed:
I need to pick out some crystals in a darker background (.png images). The program should pick what it believes to be a crystal and color it red, while the rest of the image remains black. Here are some issues that make this challenging (i.e. can't just use a typical threshold feature):

1. Crystals vary in brightness dramatically. Some are bright, while others almost melt into the background.
2. The background itself is somewhat noisy changes and brightness gradually, so a single baseline value can't be used.
3. Especially dark blotches in background exist: these may make it look as if a crystal starts right after one if an algorithm is not properly configured.
4. Some of the bright crystals have a fuzz halo around them that should not be counted as part of the crystal.
5. The program needs to successfully and accurately find at least 90-95% of the crystals.
I don't see an option for posting an example image here, unfortunately.

What I have so far:
1. Have a progressive baseline average for hue moving across the image, and count anything above that value beyond a certain threshold as a crystal.
2. Move both left to right and down an image to improve detection.
3. Using SFML for image processing as that's the easiest thing I know of.
4. Plan to use statistically "unusual" points (i.e. >3 constantly rising hue values) as an indication of a crystal.
5. Plan to use consistently falling values as possible indication of fuzz to "demote" some found crystal pixels to non-pixel status.
The code uses a helper "support.png" file in which a red region on the left and at the top of the image (for the two travel directions) identifies the initial background regions for the program.

Haven't implemented 4 and 5 yet, both should help, but now my program still doesn't fully find some of the darker crystals (though I can fairly clearly distinguish them by eye) and picks up a bit too much fuzz on the brighter ones. Clearly changing the threshold will merely cause a tradeoff between these two, while I need to improve them simultaneously. Any ideas would be greatly appreciated.

Here is my code so far:

#include <iostream>
#include <vector>
#include <string>
#include <SFML/Graphics.hpp>

int X;	// Resolution
int Y;

using namespace std;

class List10 {
private:
	vector<int> list;
public:
	int size();
	void add(int);
	void reset()
	{
		list.clear();
	}
	double average();
	int operator[](int i)
	{
		return list[i];
	}
};

int List10::size()
{
	return list.size();
}
void List10::add(int val)
{
	if (list.size() < 10)
	{
		list.push_back(val);
	}
	else
	{
		for (int i = 1; i < list.size(); i++)
		{
			list[i - 1] = list[i];
		}
		list[9] = val;
	}
}

double List10::average()
{
	double sum = 0;
	for (int i = 0; i <= list.size(); i++)
		sum += list[i];
	return sum / list.size();
}


int main()
{
	string inFile;
	cout << "Enter the input .png file: ";
	cin >> inFile;
	cout << "Enter a threshold (pixels): ";
	int threshold;
	cin >> threshold;

	sf::Image inImage;
	sf::Image inImage2;
	sf::Image outImage;
	inImage.loadFromFile(inFile);
	inImage2.loadFromFile("support.png");

	sf::Vector2u frameSize = inImage.getSize();
	X = frameSize.x;
	Y = frameSize.y;

	outImage.create(X, Y, sf::Color::Black);

	vector<vector<int>> hue(Y, vector<int>(X));
	vector<vector<bool>> crystal(Y, vector<bool>(X));

	sf::Color color;

	// Load image into 2d vector
	for (int y = 0; y < Y; ++y)
	{
		for (int x = 0; x < X; ++x)
		{
			color = inImage.getPixel(x, y);
			sat[y][x] = hue[y][x] = color.b + color.g + color.r;
			if (color.g != 0 && color.r == 0)
				hue[y][x] += 255;
			else if (color.r != 0)
				hue[y][x] += 510;
		}
	}

	int x2;
	int y2;
	int up = 0;
	List10 base10;
	int base;

	for (int y = 0; y < Y; ++y)
	{
		for (int x = 0; x < X; ++x)
		{
			color = inImage2.getPixel(x, y);
			if (color == sf::Color::Red)
			{
				base10.add(hue[y][x]);
				base = base10.average();
				//cout << "1\n";
			}
			else if (base10.size() == 0)
			{
				x2 = x + 1;
				//cout << "2\n";
				while (inImage2.getPixel(x2, y) != sf::Color::Red)
				{
					++x2;
				}
				base10.add(hue[y][x2]);
				base = base10.average();
			}
			else if (hue[y][x] - base > threshold || up > 3)
			{
				//cout << "3\n";
				crystal[y][x] = true;
				outImage.setPixel(x, y, sf::Color::Red);
			}
			else if (hue[y][x] - base > -6)	// Avoid black blotches in background
			{
				//cout << "4\n";
				base10.add(hue[y][x]);
				base = base10.average();
			}
			//cout << "Row " << y << " done.\n";
		}
		base10.reset();
	}

	for (int x = 0; x < X; ++x)
	{
		for (int y = 0; y < Y; ++y)
		{
			color = inImage2.getPixel(x, y);
			if (color == sf::Color::Red)
			{
				base10.add(hue[y][x]);
				base = base10.average();
				//cout << "1\n";
			}
			else if (base10.size() == 0)
			{
				y2 = y + 1;
				//cout << "2\n";
				while (inImage2.getPixel(x, y2) != sf::Color::Red)
				{
					++y2;
				}
				base10.add(hue[y2][x]);
				base = base10.average();
			}
			else if (hue[y][x] - base > threshold || up > 3)
			{
				//cout << "3\n";
				crystal[y][x] = true;
				outImage.setPixel(x, y, sf::Color::Red);
			}
			else if (hue[y][x] - base > -6)	// Avoid black blotches in background
			{
				//cout << "4\n";
				base10.add(hue[y][x]);
				base = base10.average();
			}
			//cout << "Out\n";
		}
		base10.reset();
	}

	// Remove noise and smooth image
	int neighbors;

	for (int y = 1; y < Y - 1; ++y)
	{
		for (int x = 1; x < X - 1; ++x)
		{
			neighbors = 0;
			if (crystal[y][x] == 1)
			{
				if (crystal[y][x + 1] == 1)
					++neighbors;
				if (crystal[y][x - 1] == 1)
					++neighbors;
				if (crystal[y + 1][x] == 1)
					++neighbors;
				if (crystal[y - 1][x] == 1)
					++neighbors;
				if (crystal[y + 1][x + 1] == 1)
					++neighbors;
				if (crystal[y - 1][x - 1] == 1)
					++neighbors;
				if (crystal[y + 1][x - 1] == 1)
					++neighbors;
				if (crystal[y - 1][x + 1] == 1)
					++neighbors;

				if (neighbors < 4)
				{
					crystal[y][x] = 0;
					outImage.setPixel(x, y, sf::Color::Black);
				}
			}
		}
	}

	// Smoothed image
	outImage.saveToFile("output2.png");

	ofstream fout;
	string outFile = inFile;

	fout.open(outFile + "-hue.csv");
	for (int row = 0; row < Y; ++row)
	{
		for (int col = 0; col < X; ++col)
			fout << hue[row][col] << ',';
		fout << endl;
	}
	fout.close();

	fout.open(outFile + "-sat.csv");
	for (int row = 0; row < Y; ++row)
	{
		for (int col = 0; col < X; ++col)
			fout << sat[row][col] << ',';
		fout << endl;
	}
	fout.close();

	system("pause");
	return 0;
}