C++ BMP::TellBitDepth方法代码示例

unsigned int loadImage(const char * fname)
{
	if ( ! fname )
	{
		return 0;
	}
	BMP bmp;
	if ( ! bmp.ReadFromFile(fname) )
	{
		printf( "not loaded : %s\n",fname );
		return 0;
	}

	int w = bmp.TellWidth();
	int h = bmp.TellHeight();
	int d = bmp.TellBitDepth() / 8;
    RGBApixel* pix = bmp(0,0);
    char bytes[0x7ffff], *b=bytes;
    for ( int j=0; j<h; j++ )
    {
        for ( int i=0; i<w; i++ )
        {
			RGBApixel pix = bmp.GetPixel(i, j);
            *b++ = pix.Red;
            *b++ = pix.Green;
            *b++ = pix.Blue;
			if ( d == 4 )
				*b++ = pix.Alpha;            
        }        
    }
    size_t i = RGL::texCreate( w, h, d, bytes, true );;
    printf( "created : %d [%d %d %d] %s\n", i, w,h,d,fname );
    return i;
}

void PadBMP( BMP& Input , int NewWidth , int NewHeight )
{
// if the NewWidth and NewHight are unchanged, exit

    if( NewWidth  == Input.TellWidth() &&
            NewHeight == Input.TellHeight() )
    {
        return;
    }

// find max range for the copy, so that cropping occurs
// if necessary

    int MaxWidth = Input.TellWidth();
    if( MaxWidth > NewWidth )
    {
        MaxWidth = NewWidth;
    }

    int MaxHeight = Input.TellHeight();
    if( MaxHeight > NewHeight )
    {
        MaxHeight = NewHeight;
    }

// create a temporary image to hold the original pixels

    BMP Temp;
    Temp.SetSize(NewWidth,NewHeight);
    Temp.SetBitDepth( Input.TellBitDepth() );
    int i,j;
    int Difference = Temp.TellHeight() - MaxHeight;
    for( i=0 ; i < MaxWidth ; i++ )
    {
        for( j=0 ; j < MaxHeight ; j++ )
        {
            *Temp(i,j+Difference) = *Input(i,j);
        }
    }

// resize the original image, and recopy the pixels

    Input.SetSize(NewWidth,NewHeight);
    for( i=0 ; i < Input.TellWidth() ; i++ )
    {
        for( j=0 ; j < Input.TellHeight() ; j++ )
        {
            *Input(i,j) = *Temp(i,j);
        }
    }

    Temp.SetSize(1,1);
    Temp.SetBitDepth(24);

    return;
}

int importImg(char* filename){
  BMP InputIMG;
  cout << "Starting BMP final code" << endl;
  
  cout << "Open File: " << filename << endl;
  if(!InputIMG.ReadFromFile(filename)){
    cout << "Invalid File Name..." << endl;
    return EXIT_FAILURE;
  }

  printFileInfo(InputIMG);
  COLUMNS = InputIMG.TellWidth();  // num cols
  ROWS = InputIMG.TellHeight(); // num rows
  DEPTH = InputIMG.TellBitDepth();
  
  //allocate Memory
  imageArray = new int *[COLUMNS] ; // row memory allocation
  for( int i = 0 ; i < COLUMNS ; i++ ){ // column memory allocation
    imageArray[i] = new int[ROWS];
  }

  thetas = new float *[COLUMNS];
  for(int i = 0; i < COLUMNS; i++) {
    thetas[i] = new float[ROWS];
  }

  magArray = new int *[COLUMNS];
  for(int i=0; i < COLUMNS; i++) {
    magArray[i] = new int[ROWS];
  }

  int Temp;
  cout<< "Saving Brightness values" << endl;
  for( int j=0 ; j < ROWS ; j++)
    {
      for( int i=0 ; i < COLUMNS ; i++)
	{
	  Temp = (int) floor( 0.299*InputIMG(i,j)->Red +
			      0.587*InputIMG(i,j)->Green +
			      0.114*InputIMG(i,j)->Blue );
	  imageArray[i][j] = Temp;
	}
    }

}

void printFileInfo(BMP image){
  cout << endl << "File info:" << endl;
  cout << image.TellWidth() << " x " << image.TellHeight()
       << " at " << image.TellBitDepth() << " bpp" << endl << endl;
}

int main( int argc, char* argv[] )
{
    if( argc != 4 )
	{
		cout << "Usage: " << argv[0] << " (-t|-b) <inputfile.bmp> <outputfile.txt>"
		   	<< endl << endl;
		return 1;
	}
	
	//eventually, take these as parameters
	ringID = 128;
	ringOD = 686;
	numLEDs = 32;
	numSlices = 256;
	int *ledOrder = NULL;

	if( string(argv[1]) == "-t" ) {
		mirror = false;
		rotation = 0;
		int arr[] = {16,18,20,22,24,26,28,30,17,19,21,23,25,27,29,31,
							15,13,11,9,7,5,3,1,14,12,10,8,6,4,2,0};
		ledOrder = &arr[0];
	}
	else if( string(argv[1]) == "-b" ) {
		mirror = true;
		rotation = 0;
		int arr[] = {30,28,26,24,22,20,18,16,31,29,27,25,23,21,19,17,
							1,3,5,7,9,11,13,15,0,2,4,6,8,10,12,14};
		ledOrder = &arr[0];
	}
	else {
		cout << "Usage: " << argv[0] << " (-t|-b) <inputfile.bmp> <outputfile.txt>"
		   	<< endl << endl;
		return 1;
	}

	// ledOrder[0] = 16 means to light LED at r=0 (first LED), the 17th bit must be set
	// (set the bit with |= (1 << 16).
	// So ledOrder[31] = 0 means to light LED at r=31 (32nd LED), the 1st bit must be set.
	
	// read the bitmap and make sure it's square and 1 bpp
	if (!input.ReadFromFile(argv[2]))
		return 1;
	
	width = input.TellWidth();
	height = input.TellHeight();
	depth = input.TellBitDepth();

	cout << "BMP info:  " << width << " x " << height << " @ " << depth << " bpp" << endl;
	
	if ( width != height || depth != 1 )
	{
		cout << "Bad file -- must be square and 1 bpp depth." << endl << endl;
		return 1;
	}

	char* outputFile = argv[3];

	//calcGeometry(ringID, ringOD, height, width, numLEDs, numSlices);
	calcGeometry();

	// make an array of radialpixels
	RadialPixel radpix[numLEDs * numSlices];
	
	for (int j=0; j<numSlices; j++) {
		for (int i=0; i<numLEDs; i++) {
			radpix[numLEDs * j + i].th = j;
			radpix[numLEDs * j + i].r = i;
			setRadialPixel(&radpix[numLEDs * j + i]);
		}
	}

	// translate the radialpixels to bytecode
	FILE *out;
	out = fopen (outputFile,"w");
	makeByteCode(radpix, ledOrder, out);
	fclose(out);

	cout << "Byte code written to " << outputFile << endl << endl;
	return 0;
}

        bool ImportBMP( _TImg_t           & out_timg, 
                        const std::string & filepath, 
                        unsigned int        forcedwidth, 
                        unsigned int        forcedheight, 
                        bool                erroronwrongres )
    {
        //The max nb of colors possible with that bitdepth!
        static const unsigned int NB_Colors_Support = utils::do_exponent_of_2_<_TImg_t::pixel_t::mypixeltrait_t::BITS_PER_PIXEL>::value;
        
        bool   hasWarnedOORPixel = false; //Whether we warned about out of range pixels at least once during the pixel loop! If applicable..
        bool   isWrongResolution = false;
        BMP    input;
        auto & outpal = out_timg.getPalette();

        input.ReadFromFile( filepath.c_str() );

        if( input.TellBitDepth() != _TImg_t::pixel_t::GetBitsPerPixel() )
        {
            //We don't support anything with a different bitdepth!
            //Mention the palette length mismatch
            cerr <<"\n<!>-ERROR: The file : " <<filepath <<", is not a " <<_TImg_t::pixel_t::GetBitsPerPixel() 
                 <<"bpp indexed bmp ! Its in fact " <<input.TellBitDepth() <<"bpp!\n"
                 <<"Make sure the bmp file is saved as " <<_TImg_t::pixel_t::GetBitsPerPixel() <<"bpp, "
                 <<NB_Colors_Support << " colors!\n";

            return false;
        }

        //Only force resolution when we were asked to!
        if( forcedwidth != 0 && forcedheight != 0 )
            isWrongResolution = input.TellWidth() != forcedwidth || input.TellHeight() != forcedheight;
        if( erroronwrongres && isWrongResolution )
        {
            cerr <<"\n<!>-ERROR: The file : " <<filepath <<" has an unexpected resolution!\n"
                 <<"             Expected :" <<forcedwidth <<"x" <<forcedheight <<", and got " <<input.TellWidth() <<"x" <<input.TellHeight() 
                 <<"! Skipping!\n";
            return false;
        }


        if( utils::LibraryWide::getInstance().Data().isVerboseOn() && input.TellNumberOfColors() <= NB_Colors_Support )
        {
            //Mention the palette length mismatch
            cerr <<"\n<!>-Warning: " <<filepath <<" has a different palette length than expected!\n"
                 <<"Fixing and continuing happily..\n";
        }
        out_timg.setNbColors( NB_Colors_Support );

        //Build palette
        const unsigned int nbColors = static_cast<unsigned int>( ( input.TellNumberOfColors() > 0 )? input.TellNumberOfColors() : 0 );
        if( nbColors == 0 )
            throw runtime_error("ERROR: BMP image being imported has an invalid palette!");
        for( unsigned int i = 0; i < nbColors; ++i )
        {
            RGBApixel acolor = input.GetColor(i);
            outpal[i].red   = acolor.Red;
            outpal[i].green = acolor.Green;
            outpal[i].blue  = acolor.Blue;
            //Alpha is ignored
        }

        //Image Resolution
        int tiledwidth  = (forcedwidth  != 0)? forcedwidth  : input.TellWidth();
        int tiledheight = (forcedheight != 0)? forcedheight : input.TellHeight();

        //Make sure the height and width are divisible by the size of the tiles!
        if( tiledwidth % _TImg_t::tile_t::WIDTH )
            tiledwidth = CalcClosestHighestDenominator( tiledwidth,  _TImg_t::tile_t::WIDTH );

        if( tiledheight % _TImg_t::tile_t::HEIGHT )
            tiledheight = CalcClosestHighestDenominator( tiledheight,  _TImg_t::tile_t::HEIGHT );

        //Resize target image
        out_timg.setPixelResolution( tiledwidth, tiledheight );

        //If the image we read is not divisible by the dimension of our tiles, 
        // we have to ensure that we won't got out of bound while copying!
        int maxCopyWidth  = out_timg.getNbPixelWidth();
        int maxCopyHeight = out_timg.getNbPixelHeight();

        if( maxCopyWidth != input.TellWidth() || maxCopyHeight != input.TellHeight() )
        {
            //Take the smallest resolution, so we don't go out of bound!
            maxCopyWidth  = std::min( input.TellWidth(),  maxCopyWidth );
            maxCopyHeight = std::min( input.TellHeight(), maxCopyHeight );
        }

        //Copy pixels over
        for( int i = 0; i < maxCopyWidth; ++i )
        {
            for( int j = 0; j < maxCopyHeight; ++j )
            {
                RGBApixel apixel = input.GetPixel(i,j);

                //First we need to find out what index the color is..
                gimg::colorRGB24::colordata_t colorindex = FindIndexForColor( apixel, outpal );

                if( !hasWarnedOORPixel && colorindex == -1 )
                {
                    //We got a problem
//.........这里部分代码省略.........

int main(int argc, char* argv[]) {
	srand (time(NULL));

	int fracSelect = atoi(argv[1]);
	int colSelect = atoi(argv[2]);
	int x0 = atoi(argv[3]);
	int x1 = atoi(argv[4]);
	int y0 = atoi(argv[5]);
	int y1 = atoi(argv[6]);
	double width = atoi(argv[7]);
	double height = atoi(argv[8]);

	vector<Fractal*> fracSel(5);
	fracSel[0] = new Mandelbrot();
	fracSel[1] = new BurningShip();
	fracSel[2] = new BlurningShip();
	fracSel[3] = new RandNumb();
	fracSel[4] = new Eye();


	vector<Colorer*> colSel(10);
	colSel[0] = new RedAlphaColorer();
	colSel[1] = new GreenAlphaColorer();
	colSel[2] = new BlueAlphaColorer();
	colSel[3] = new GrayAlphaColorer();
	colSel[4] = new RedColorer();
	colSel[5] = new GreenColorer();
	colSel[6] = new BlueColorer();
	colSel[7] = new GrayColorer();
	colSel[8] = new EclipseColorer();
	colSel[9] = new InverseColorer();

	// Declare a new bitmap object
	BMP AnImage;
	// Set size to 640 £ 480
	AnImage.SetSize(width,height);
	// Set its color depth to 8-bits
	AnImage.SetBitDepth(32);

	cout << "File info:" << endl;
	cout << AnImage.TellWidth() << " x " << AnImage.TellHeight()
		<< " at " << AnImage.TellBitDepth() << " bpp" << endl;

#pragma omp parallel
	{
#pragma omp for
		for(int x = 0.0; x < int(width); x+= 1.0){
			for(int y = 0.0; y < int(height); y += 1.0){
				double xcurr = map(x, 0, width, x0, x1); //Change last two inputs to user input
				double ycurr = map(y, 0, height, y0, y1); //Change last two inputs to user input
				int color = fracSel[fracSelect]->testPoint(xcurr, ycurr);
				if(color >= 255) { color = 0; }
				AnImage.SetPixel(x,y,colSel[colSelect]->colorPoint(color));
			}
		}
	}
	AnImage.WriteToFile(argv[10]);

	cout << "File save complete." << endl;

	int c;
	cin >> c;
	return EXIT_SUCCESS;
};

SbXipImage* SoXipLoadBMP::loadBMP(const char *fileName)
{
    try
    {
        BMP bmp;
        bmp.ReadFromFile(fileName);

        int numBits = bmp.TellBitDepth();
        int width = bmp.TellWidth();
        int height = bmp.TellHeight();

        int bitsStored = 8;
        int samplesPerPixel = 0;
        SbXipImage::ComponentType compType = SbXipImage::INTERLEAVED;
        SbXipImage::ComponentLayoutType compLayoutType = SbXipImage::RGB;

        if(numBits<=24)
        {
            samplesPerPixel = 3;
            compLayoutType = SbXipImage::RGB;
        }
        else if(numBits == 32)
        {
            samplesPerPixel = 4;
            compLayoutType = SbXipImage::RGBA;
        }

        SbVec3f pos(0, 0, 0);
        SbVec3f scale(width, height, 1);
        SbMatrix rotMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1);

        SbMatrix modelMatrix;
        modelMatrix.setScale(scale);
        //modelMatrix.setTransform(pos, SbRotation(rotMatrix), scale);

        SbXipImage *image = new SbXipImage(SbXipImageDimensions(width, height, 1), SbXipImageDimensions(width, height, 1),
                                           SbXipImage::UNSIGNED_BYTE, bitsStored, samplesPerPixel, compType, compLayoutType, modelMatrix);
        unsigned char *buffer = (unsigned char *) image->refBufferPtr();

        if(numBits<=24)
        {
            for(int i = 0; i < height; i++)
            {
                for(int j = 0; j < width; j++)
                {
                    RGBApixel pixel = bmp.GetPixel(j,(height -1) - i );

                    buffer[3*i*width+3*j] = pixel.Red;
                    buffer[3*i*width+3*j+1] = pixel.Green;
                    buffer[3*i*width+3*j+2] = pixel.Blue;

                }
            }
        }
        else if(numBits == 32)
        {
            for(int i=0; i<height; i++)
            {
                for(int j=0; j<width; j++)
                {
                    RGBApixel pixel = bmp.GetPixel(j, height-i);

                    buffer[4*i*width+4*j] = pixel.Red;
                    buffer[4*i*width+4*j+1] = pixel.Green;
                    buffer[4*i*width+4*j+2] = pixel.Blue;
                    buffer[4*i*width+4*j+3] = pixel.Alpha;
                }
            }
        }

        image->unrefBufferPtr();

        return image;
    }
    catch(...)
    {
        SoDebugError::postInfo(__FILE__, "Exception loadBMP");

        // Fix me need to delete allocated memory!
        return 0;
    }
}