Bits byte

I actually did change it to this...

Code:

const unsigned int bit[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
				int binValue = 0;
		int count = 0;
		int j = 0;

		for(int k=0; k < imageLength; k++)
		{
			for(int i=0; i < imageWidth; i++)
			{
				if(j > 7) j = 0;
				binValue = (buf[i] & bit[j]) >> j;
				cout << binValue;
				j++;
			}
			cout << endl;
		}

Can someone try this and see if they are getting the correct values?

The next step (if this works) is to get the output to reverse what it is right now... any suggestions on the fastest way to do that?

I've not tried it, but it seems like it would work, even if it's a little complicated.

If you insist on using your array, why not just use a simple comparison rather than a shift? It would make your code easier to read...

Code:

const unsigned int bit[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
				int binValue = 0;
		int count = 0;
		int j = 0;

		for(int k=0; k < imageLength; k++)
		{
			for(int i=0; i < imageWidth; i++)
			{
				if(j > 7) j = 0;
				binValue = ((buf[i] & bit[j]) ? 1 : 0 );
				cout << binValue;
				j++;
			}
			cout << endl;
		}

ok, I made that change... but I'm trying to isolate the problem of why my program won't work (properly) ... Do you think this is all working properly? This part, at least.

Well, from looking at it, your program checks the 7th bit of the first byte, and then the 6th bit of the second byte, 5th bit of the third byte/etc and so on - is this what it is supposed to do? If not, then you need to loop J to check every bit before moving onto the next byte.

To test for a single bit in a number:

Code:

bool testBit( int number, int bitIndex)
{
  return number &  1<<bitIndex;
}

Originally posted by Sang-drax
To test for a single bit in a number:

Code:

bool testBit( int number, int bitIndex)
{
  return number &  1<<bitIndex;
}

Slight correction here on your code:

return !!(number & 1 << bitIndex);

Without the double not statement, you are not actually returning a boolean value. The only way you would, would be if bitIndex was zero. Anything else does not return 1. It returns a power of two.

While it is true that it would work for an equality test, where anything non-zero is considered true, in your case, it is incorrect, because bool should only ever be one or zero.

This would fail:

if( testBit( 2, 1 ) == 1 )

Because "number & 2" would return two, not one.

Quzah.

I have added comments to show what I believe this does... Please correct me if I'm wrong. And if there's an easier/better/right way to do it.

(it says PHP but that's just so you can see the color and it's easier to read)

PHP Code:

        int binValue = 0;
        int j = 0;

        for(int k=0; k < imageLength; k++)                    //loops to the start of every line of pixels
        {
            for(int i=0; i < imageWidth; i++)                //loops to each pixel in the line
            {
                if(j > 7) j = 0;                            //restarts the bit count
                binValue = ((buf[i] & mask[j]) ? 1 : 0 );    //checks the bit if it's on or off
                cout << binValue;
                j++;                                        //increments bit count
            }
            cout << endl;
        } 


I can tell what your code does without comments, and it still does exactly what I described above - checks exactly one bit in each byte. Why? Because "y" is incremented only after "i" has changed.

The program, as it stands, checks the 7th bit of the first byte, and then the 6th bit of the second byte, 5th bit of the third byte/etc and so on, like I said above before you ignored my post

It seems like the loop is not correct:

Code:

 binValue = ((buf[i] & mask[j]) ? 1 : 0 );

you would first get buf[0] & mask[0]
but then it would be buf[1] & mask[1]

dont you want to compare every bit in the byte before moving on to the next one?

maybe add another loop:

Code:

for(int i=0; i < imageWidth; i++)                
            {
                 for (int j; j < 7; j++)                            
                {
                   binValue = ((buf[i] & mask[j]) ? 1 : 0 );    
                    cout << binValue;
                }  
                                  
            }

but I really don't understand what you are doing...

I think JaWib is right. Assuming you want to check all eight bits per byte, you need another loop. And if you want to print the most sigficicant bit first (instead of the least significant bit), just change the bit array (old code commented).

Code:

   const unsigned int bit[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   int binValue, j;
   int byte = 0;

   for (int k=0; k < imageLength; k++)
   {
      for (int i=0; i < imageWidth; i++)
      {
         //if(j > 7) j = 0;
         for (j=0; j<8; j++)
         {
	    //binValue = ((buf[i] & bit[j]) ? 1 : 0 );
	    binValue = ((buf[byte] & bit[j]) ? 1 : 0 );
	    cout << binValue;
         }
         cout << " ";
         byte++;
	 //j++;
      }
      cout << endl;
   }

Originally posted by adrianxw
You should be using a bitmask not an integer, i.e. instead of 1 use 0x01, instead of 10 use 0x02, 100 - 0x04 1000 - 0x08 10000 - 0x10, 100000 - 0x20, 1000000 - 0x40 and 10000000 - 0x80.

Is it possible to AND with decimals 1,2,4,8,16,32,64, etc? I don't care if it's not the standard way, but is it possible?

I don't understand x & 0["@"]. Is "0" a system defined character array?

I still don't understand. Is Steve Summit saying that 5["abcdef"] will return 'f'? As if you've said "abcdef"[5]?

>>>
Is it possible to AND with decimals 1,2,4,8,16,32,64, etc? I don't care if it's not the standard way, but is it possible?
<<<

Yes of course, the point I was making is he was not using 1,2,4... he was using 1, 10, 100...

Point taken, adrian. That's interesting Salem, although I've never seen that method used in any code.