void P3Grayscale::convertToMonochrome()
{
fstream image(fileName);
skipHeader(image);
int amountOfPixelsInImage = 0;
int num;
for (; false == image.eof(); amountOfPixelsInImage++)
{
image >> num;
image >> num;
image >> num;
}
image.clear();
image.seekg(0);
skipHeader(image);
int numToCheck;
int* blackAndWhitePixelValues = new int[amountOfPixelsInImage];
for (int i = 0; i < amountOfPixelsInImage; i++)
{
image >> numToCheck;
image >> numToCheck;
image >> numToCheck;
if (numToCheck <= maxValue / 2)
blackAndWhitePixelValues[i] = 0;
else
blackAndWhitePixelValues[i] = maxValue;
}
image.close();
ifstream imageOriginal(fileName);
ofstream imageCopy(fileCopyName);
copyHeader(imageCopy, imageOriginal);
imageOriginal.close();
for (int i = 0; i < amountOfPixelsInImage; i++)
{
imageCopy << blackAndWhitePixelValues[i] << ' '; //R
imageCopy << blackAndWhitePixelValues[i] << ' '; //G
imageCopy << blackAndWhitePixelValues[i] << ' '; //B
}
imageCopy.close();
delete[] blackAndWhitePixelValues;
}
static void Apply( GenericImage<P>& image, const LocalHistogramEqualizationInstance& instance )
{
if ( image.IsColor() )
{
Image L;
image.GetLightness( L );
L.Status() = image.Status();
Apply( L, instance );
image.Status() = L.Status();
image.SetLightness( L );
return;
}
// create copy of the luminance to evaluate histogram from
GenericImage<P> imageCopy( image );
imageCopy.EnsureUnique(); // really not necessary, but we'll be safer if this is done
size_type N = image.NumberOfPixels();
int numberOfThreads = Thread::NumberOfThreads( image.Height(), 1 );
int rowsPerThread = image.Height()/numberOfThreads;
image.Status().Initialize( "CLAHE", N );
AbstractImage::ThreadData data( image, N );
// create processing threads
ReferenceArray<LocalHistogramEqualizationThread<P> > threads;
for ( int i = 0, j = 1; i < numberOfThreads; ++i, ++j )
threads.Add( new LocalHistogramEqualizationThread<P>( data,
instance,
image,
imageCopy,
i*rowsPerThread,
(j < numberOfThreads) ? j*rowsPerThread : image.Height() ) );
AbstractImage::RunThreads( threads, data );
threads.Destroy();
image.Status() = data.status;
}
void P6Grayscale::convertToMonochrome()
{
fstream image(fileName, ios::binary);
skipHeader(image);
int amountOfPixelsInImage = 0;
unsigned char num[1];
unsigned char* numP = &num[0];
for (; false == image.eof(); amountOfPixelsInImage++)
{
image.read((char*)numP, 1);
image.read((char*)numP, 1);
image.read((char*)numP, 1);
}
image.clear();
image.seekg(0);
skipHeader(image);
unsigned char numToCheck[1];
unsigned char* numToCheckPointer = &numToCheck[0];
unsigned char* blackAndWhitePixelValues;
try
{
blackAndWhitePixelValues = new unsigned char[amountOfPixelsInImage];
}
catch (exception& e)
{
cout << "Standard exception: " << e.what() << endl;
return;
}
for (int i = 0; i < amountOfPixelsInImage; i++)
{
image.read((char*)numToCheckPointer, 1);
image.read((char*)numToCheckPointer, 1);
image.read((char*)numToCheckPointer, 1);
if (numToCheck[0] <= maxValue / 2)
blackAndWhitePixelValues[i] = 0;
else
blackAndWhitePixelValues[i] = maxValue;
}
image.close();
ifstream imageOriginal(fileName, ios::binary);
ofstream imageCopy(fileCopyName, ios::binary);
copyHeader(imageCopy, imageOriginal);
unsigned char* blackAndWhitePixelValuesPointer = &blackAndWhitePixelValues[0];
for (int i = 0; i < amountOfPixelsInImage; i++, blackAndWhitePixelValuesPointer++)
{
image.write((char*)blackAndWhitePixelValuesPointer, 1);
image.write((char*)blackAndWhitePixelValuesPointer, 1);
image.write((char*)blackAndWhitePixelValuesPointer, 1);
}
image.close();
delete[] blackAndWhitePixelValues;
}
